From 93729784bb1c4e544e07ec27a43ef57c4f456cec Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 13:35:51 +0300 Subject: [PATCH 01/10] dnn: move module from opencv_contrib https://github.com/opencv/opencv_contrib/tree/e6f63c7a38ca40c5dc33e38736e3027e3528d6cb/modules/dnn --- modules/dnn/CMakeLists.txt | 84 + modules/dnn/README.md | 2 + modules/dnn/include/opencv2/dnn.hpp | 64 + .../dnn/include/opencv2/dnn/all_layers.hpp | 471 + modules/dnn/include/opencv2/dnn/dict.hpp | 146 + modules/dnn/include/opencv2/dnn/dnn.hpp | 655 + modules/dnn/include/opencv2/dnn/dnn.inl.hpp | 357 + modules/dnn/include/opencv2/dnn/layer.hpp | 148 + .../dnn/include/opencv2/dnn/shape_utils.hpp | 195 + modules/dnn/misc/caffe/caffe.pb.cc | 53676 ++++++++++++++++ modules/dnn/misc/caffe/caffe.pb.h | 28612 ++++++++ modules/dnn/misc/python/pyopencv_dnn.hpp | 39 + modules/dnn/misc/tensorflow/attr_value.pb.cc | 3014 + modules/dnn/misc/tensorflow/attr_value.pb.h | 1697 + modules/dnn/misc/tensorflow/function.pb.cc | 2348 + modules/dnn/misc/tensorflow/function.pb.h | 1160 + modules/dnn/misc/tensorflow/graph.pb.cc | 1687 + modules/dnn/misc/tensorflow/graph.pb.h | 814 + modules/dnn/misc/tensorflow/op_def.pb.cc | 4045 ++ modules/dnn/misc/tensorflow/op_def.pb.h | 2103 + modules/dnn/misc/tensorflow/tensor.pb.cc | 1596 + modules/dnn/misc/tensorflow/tensor.pb.h | 770 + .../dnn/misc/tensorflow/tensor_shape.pb.cc | 895 + modules/dnn/misc/tensorflow/tensor_shape.pb.h | 423 + modules/dnn/misc/tensorflow/types.pb.cc | 163 + modules/dnn/misc/tensorflow/types.pb.h | 129 + modules/dnn/misc/tensorflow/versions.pb.cc | 572 + modules/dnn/misc/tensorflow/versions.pb.h | 239 + modules/dnn/perf/perf_convolution.cpp | 106 + modules/dnn/perf/perf_halide_net.cpp | 172 + modules/dnn/perf/perf_main.cpp | 12 + modules/dnn/perf/perf_precomp.hpp | 17 + modules/dnn/samples/.gitignore | 1 + ...GG_VOC0712_SSD_300x300_iter_60000.prototxt | 1546 + modules/dnn/samples/bvlc_googlenet.prototxt | 2156 + modules/dnn/samples/caffe_googlenet.cpp | 143 + modules/dnn/samples/enet-classes.txt | 20 + .../dnn/samples/fcn32s-heavy-pascal.prototxt | 502 + .../dnn/samples/fcn8s-heavy-pascal.prototxt | 612 + modules/dnn/samples/fcn_semsegm.cpp | 154 + modules/dnn/samples/googlenet_python.py | 34 + modules/dnn/samples/pascal-classes.txt | 21 + modules/dnn/samples/rgb.jpg | Bin 0 -> 47099 bytes modules/dnn/samples/space_shuttle.jpg | Bin 0 -> 27598 bytes modules/dnn/samples/squeezenet_halide.cpp | 120 + modules/dnn/samples/ssd_object_detection.cpp | 154 + modules/dnn/samples/synset_words.txt | 1000 + modules/dnn/samples/tf_inception.cpp | 173 + modules/dnn/samples/torch_enet.cpp | 207 + modules/dnn/src/caffe/caffe.proto | 1581 + modules/dnn/src/caffe/caffe_importer.cpp | 382 + modules/dnn/src/caffe/caffe_io.cpp | 1151 + modules/dnn/src/caffe/caffe_io.hpp | 108 + modules/dnn/src/caffe/glog_emulator.hpp | 104 + modules/dnn/src/dnn.cpp | 2001 + modules/dnn/src/halide_scheduler.cpp | 284 + modules/dnn/src/halide_scheduler.hpp | 37 + modules/dnn/src/init.cpp | 107 + modules/dnn/src/layers/batch_norm_layer.cpp | 198 + modules/dnn/src/layers/blank_layer.cpp | 78 + modules/dnn/src/layers/concat_layer.cpp | 141 + modules/dnn/src/layers/convolution_layer.cpp | 1145 + modules/dnn/src/layers/crop_layer.cpp | 153 + .../dnn/src/layers/detection_output_layer.cpp | 798 + modules/dnn/src/layers/elementwise_layers.cpp | 502 + modules/dnn/src/layers/eltwise_layer.cpp | 219 + modules/dnn/src/layers/flatten_layer.cpp | 125 + .../dnn/src/layers/fully_connected_layer.cpp | 281 + modules/dnn/src/layers/layers_common.avx2.cpp | 356 + modules/dnn/src/layers/layers_common.cpp | 205 + modules/dnn/src/layers/layers_common.hpp | 87 + modules/dnn/src/layers/lrn_layer.cpp | 341 + .../dnn/src/layers/max_unpooling_layer.cpp | 128 + modules/dnn/src/layers/mvn_layer.cpp | 108 + .../dnn/src/layers/normalize_bbox_layer.cpp | 223 + modules/dnn/src/layers/padding_layer.cpp | 131 + modules/dnn/src/layers/permute_layer.cpp | 243 + modules/dnn/src/layers/pooling_layer.cpp | 566 + modules/dnn/src/layers/prior_box_layer.cpp | 379 + modules/dnn/src/layers/recurrent_layers.cpp | 443 + modules/dnn/src/layers/reshape_layer.cpp | 247 + modules/dnn/src/layers/scale_layer.cpp | 147 + modules/dnn/src/layers/shift_layer.cpp | 96 + modules/dnn/src/layers/slice_layer.cpp | 140 + modules/dnn/src/layers/softmax_layer.cpp | 213 + modules/dnn/src/layers/split_layer.cpp | 97 + modules/dnn/src/op_halide.cpp | 206 + modules/dnn/src/op_halide.hpp | 84 + modules/dnn/src/opencl/activations.cl | 44 + modules/dnn/src/opencl/col2im.cl | 62 + modules/dnn/src/opencl/im2col.cl | 71 + modules/dnn/src/opencl/lrn.cl | 76 + modules/dnn/src/opencl/pooling.cl | 106 + modules/dnn/src/opencl/softmax.cl | 75 + modules/dnn/src/precomp.hpp | 45 + modules/dnn/src/tensorflow/attr_value.proto | 60 + modules/dnn/src/tensorflow/function.proto | 95 + modules/dnn/src/tensorflow/graph.proto | 112 + modules/dnn/src/tensorflow/op_def.proto | 157 + modules/dnn/src/tensorflow/tensor.proto | 68 + modules/dnn/src/tensorflow/tensor_shape.proto | 45 + modules/dnn/src/tensorflow/tf_importer.cpp | 759 + modules/dnn/src/tensorflow/tf_io.cpp | 63 + modules/dnn/src/tensorflow/tf_io.hpp | 29 + modules/dnn/src/tensorflow/types.proto | 60 + modules/dnn/src/tensorflow/versions.proto | 31 + modules/dnn/src/torch/COPYRIGHT.txt | 36 + modules/dnn/src/torch/THDiskFile.cpp | 798 + modules/dnn/src/torch/THDiskFile.h | 19 + modules/dnn/src/torch/THFile.cpp | 163 + modules/dnn/src/torch/THFile.h | 90 + modules/dnn/src/torch/THFilePrivate.h | 43 + modules/dnn/src/torch/THGeneral.cpp | 256 + modules/dnn/src/torch/THGeneral.h | 89 + modules/dnn/src/torch/torch_importer.cpp | 1025 + .../dnn/test/cityscapes_semsegm_test_enet.py | 142 + modules/dnn/test/cnpy.cpp | 291 + modules/dnn/test/cnpy.h | 294 + modules/dnn/test/imagenet_cls_test_alexnet.py | 246 + .../dnn/test/imagenet_cls_test_googlenet.py | 43 + .../dnn/test/imagenet_cls_test_inception.py | 79 + modules/dnn/test/npy_blob.hpp | 65 + modules/dnn/test/pascal_semsegm_test_fcn.py | 225 + modules/dnn/test/test_caffe_importer.cpp | 160 + modules/dnn/test/test_common.hpp | 60 + modules/dnn/test/test_googlenet.cpp | 107 + modules/dnn/test/test_halide_layers.cpp | 626 + modules/dnn/test/test_halide_nets.cpp | 173 + modules/dnn/test/test_layers.cpp | 417 + modules/dnn/test/test_main.cpp | 20 + modules/dnn/test/test_precomp.hpp | 62 + modules/dnn/test/test_tf_importer.cpp | 74 + modules/dnn/test/test_torch_importer.cpp | 207 + modules/dnn/tutorials/images/build_1.png | Bin 0 -> 32126 bytes modules/dnn/tutorials/images/build_2.png | Bin 0 -> 41345 bytes modules/dnn/tutorials/images/build_3.png | Bin 0 -> 46802 bytes modules/dnn/tutorials/images/build_4.png | Bin 0 -> 40770 bytes modules/dnn/tutorials/images/build_5.png | Bin 0 -> 40924 bytes .../dnn/tutorials/images/space_shuttle.jpg | Bin 0 -> 27598 bytes .../dnn/tutorials/tutorial_dnn_build.markdown | 68 + .../tutorials/tutorial_dnn_googlenet.markdown | 66 + .../tutorials/tutorial_dnn_halide.markdown | 132 + .../tutorial_dnn_halide_scheduling.markdown | 82 + 143 files changed, 135205 insertions(+) create mode 100644 modules/dnn/CMakeLists.txt create mode 100644 modules/dnn/README.md create mode 100644 modules/dnn/include/opencv2/dnn.hpp create mode 100644 modules/dnn/include/opencv2/dnn/all_layers.hpp create mode 100644 modules/dnn/include/opencv2/dnn/dict.hpp create mode 100644 modules/dnn/include/opencv2/dnn/dnn.hpp create mode 100644 modules/dnn/include/opencv2/dnn/dnn.inl.hpp create mode 100644 modules/dnn/include/opencv2/dnn/layer.hpp create mode 100644 modules/dnn/include/opencv2/dnn/shape_utils.hpp create mode 100644 modules/dnn/misc/caffe/caffe.pb.cc create mode 100644 modules/dnn/misc/caffe/caffe.pb.h create mode 100644 modules/dnn/misc/python/pyopencv_dnn.hpp create mode 100644 modules/dnn/misc/tensorflow/attr_value.pb.cc create mode 100644 modules/dnn/misc/tensorflow/attr_value.pb.h create mode 100644 modules/dnn/misc/tensorflow/function.pb.cc create mode 100644 modules/dnn/misc/tensorflow/function.pb.h create mode 100644 modules/dnn/misc/tensorflow/graph.pb.cc create mode 100644 modules/dnn/misc/tensorflow/graph.pb.h create mode 100644 modules/dnn/misc/tensorflow/op_def.pb.cc create mode 100644 modules/dnn/misc/tensorflow/op_def.pb.h create mode 100644 modules/dnn/misc/tensorflow/tensor.pb.cc create mode 100644 modules/dnn/misc/tensorflow/tensor.pb.h create mode 100644 modules/dnn/misc/tensorflow/tensor_shape.pb.cc create mode 100644 modules/dnn/misc/tensorflow/tensor_shape.pb.h create mode 100644 modules/dnn/misc/tensorflow/types.pb.cc create mode 100644 modules/dnn/misc/tensorflow/types.pb.h create mode 100644 modules/dnn/misc/tensorflow/versions.pb.cc create mode 100644 modules/dnn/misc/tensorflow/versions.pb.h create mode 100644 modules/dnn/perf/perf_convolution.cpp create mode 100644 modules/dnn/perf/perf_halide_net.cpp create mode 100644 modules/dnn/perf/perf_main.cpp create mode 100644 modules/dnn/perf/perf_precomp.hpp create mode 100644 modules/dnn/samples/.gitignore create mode 100644 modules/dnn/samples/VGG_VOC0712_SSD_300x300_iter_60000.prototxt create mode 100644 modules/dnn/samples/bvlc_googlenet.prototxt create mode 100644 modules/dnn/samples/caffe_googlenet.cpp create mode 100644 modules/dnn/samples/enet-classes.txt create mode 100644 modules/dnn/samples/fcn32s-heavy-pascal.prototxt create mode 100644 modules/dnn/samples/fcn8s-heavy-pascal.prototxt create mode 100644 modules/dnn/samples/fcn_semsegm.cpp create mode 100644 modules/dnn/samples/googlenet_python.py create mode 100644 modules/dnn/samples/pascal-classes.txt create mode 100644 modules/dnn/samples/rgb.jpg create mode 100644 modules/dnn/samples/space_shuttle.jpg create mode 100644 modules/dnn/samples/squeezenet_halide.cpp create mode 100644 modules/dnn/samples/ssd_object_detection.cpp create mode 100644 modules/dnn/samples/synset_words.txt create mode 100644 modules/dnn/samples/tf_inception.cpp create mode 100644 modules/dnn/samples/torch_enet.cpp create mode 100644 modules/dnn/src/caffe/caffe.proto create mode 100644 modules/dnn/src/caffe/caffe_importer.cpp create mode 100644 modules/dnn/src/caffe/caffe_io.cpp create mode 100644 modules/dnn/src/caffe/caffe_io.hpp create mode 100644 modules/dnn/src/caffe/glog_emulator.hpp create mode 100644 modules/dnn/src/dnn.cpp create mode 100644 modules/dnn/src/halide_scheduler.cpp create mode 100644 modules/dnn/src/halide_scheduler.hpp create mode 100644 modules/dnn/src/init.cpp create mode 100644 modules/dnn/src/layers/batch_norm_layer.cpp create mode 100644 modules/dnn/src/layers/blank_layer.cpp create mode 100644 modules/dnn/src/layers/concat_layer.cpp create mode 100644 modules/dnn/src/layers/convolution_layer.cpp create mode 100644 modules/dnn/src/layers/crop_layer.cpp create mode 100644 modules/dnn/src/layers/detection_output_layer.cpp create mode 100644 modules/dnn/src/layers/elementwise_layers.cpp create mode 100644 modules/dnn/src/layers/eltwise_layer.cpp create mode 100644 modules/dnn/src/layers/flatten_layer.cpp create mode 100644 modules/dnn/src/layers/fully_connected_layer.cpp create mode 100644 modules/dnn/src/layers/layers_common.avx2.cpp create mode 100644 modules/dnn/src/layers/layers_common.cpp create mode 100644 modules/dnn/src/layers/layers_common.hpp create mode 100644 modules/dnn/src/layers/lrn_layer.cpp create mode 100644 modules/dnn/src/layers/max_unpooling_layer.cpp create mode 100644 modules/dnn/src/layers/mvn_layer.cpp create mode 100644 modules/dnn/src/layers/normalize_bbox_layer.cpp create mode 100644 modules/dnn/src/layers/padding_layer.cpp create mode 100644 modules/dnn/src/layers/permute_layer.cpp create mode 100644 modules/dnn/src/layers/pooling_layer.cpp create mode 100644 modules/dnn/src/layers/prior_box_layer.cpp create mode 100644 modules/dnn/src/layers/recurrent_layers.cpp create mode 100644 modules/dnn/src/layers/reshape_layer.cpp create mode 100644 modules/dnn/src/layers/scale_layer.cpp create mode 100644 modules/dnn/src/layers/shift_layer.cpp create mode 100644 modules/dnn/src/layers/slice_layer.cpp create mode 100644 modules/dnn/src/layers/softmax_layer.cpp create mode 100644 modules/dnn/src/layers/split_layer.cpp create mode 100644 modules/dnn/src/op_halide.cpp create mode 100644 modules/dnn/src/op_halide.hpp create mode 100644 modules/dnn/src/opencl/activations.cl create mode 100644 modules/dnn/src/opencl/col2im.cl create mode 100644 modules/dnn/src/opencl/im2col.cl create mode 100644 modules/dnn/src/opencl/lrn.cl create mode 100644 modules/dnn/src/opencl/pooling.cl create mode 100644 modules/dnn/src/opencl/softmax.cl create mode 100644 modules/dnn/src/precomp.hpp create mode 100644 modules/dnn/src/tensorflow/attr_value.proto create mode 100644 modules/dnn/src/tensorflow/function.proto create mode 100644 modules/dnn/src/tensorflow/graph.proto create mode 100644 modules/dnn/src/tensorflow/op_def.proto create mode 100644 modules/dnn/src/tensorflow/tensor.proto create mode 100644 modules/dnn/src/tensorflow/tensor_shape.proto create mode 100644 modules/dnn/src/tensorflow/tf_importer.cpp create mode 100644 modules/dnn/src/tensorflow/tf_io.cpp create mode 100644 modules/dnn/src/tensorflow/tf_io.hpp create mode 100644 modules/dnn/src/tensorflow/types.proto create mode 100644 modules/dnn/src/tensorflow/versions.proto create mode 100644 modules/dnn/src/torch/COPYRIGHT.txt create mode 100644 modules/dnn/src/torch/THDiskFile.cpp create mode 100644 modules/dnn/src/torch/THDiskFile.h create mode 100644 modules/dnn/src/torch/THFile.cpp create mode 100644 modules/dnn/src/torch/THFile.h create mode 100644 modules/dnn/src/torch/THFilePrivate.h create mode 100644 modules/dnn/src/torch/THGeneral.cpp create mode 100644 modules/dnn/src/torch/THGeneral.h create mode 100644 modules/dnn/src/torch/torch_importer.cpp create mode 100644 modules/dnn/test/cityscapes_semsegm_test_enet.py create mode 100644 modules/dnn/test/cnpy.cpp create mode 100644 modules/dnn/test/cnpy.h create mode 100644 modules/dnn/test/imagenet_cls_test_alexnet.py create mode 100644 modules/dnn/test/imagenet_cls_test_googlenet.py create mode 100644 modules/dnn/test/imagenet_cls_test_inception.py create mode 100644 modules/dnn/test/npy_blob.hpp create mode 100644 modules/dnn/test/pascal_semsegm_test_fcn.py create mode 100644 modules/dnn/test/test_caffe_importer.cpp create mode 100644 modules/dnn/test/test_common.hpp create mode 100644 modules/dnn/test/test_googlenet.cpp create mode 100644 modules/dnn/test/test_halide_layers.cpp create mode 100644 modules/dnn/test/test_halide_nets.cpp create mode 100644 modules/dnn/test/test_layers.cpp create mode 100644 modules/dnn/test/test_main.cpp create mode 100644 modules/dnn/test/test_precomp.hpp create mode 100644 modules/dnn/test/test_tf_importer.cpp create mode 100644 modules/dnn/test/test_torch_importer.cpp create mode 100644 modules/dnn/tutorials/images/build_1.png create mode 100644 modules/dnn/tutorials/images/build_2.png create mode 100644 modules/dnn/tutorials/images/build_3.png create mode 100644 modules/dnn/tutorials/images/build_4.png create mode 100644 modules/dnn/tutorials/images/build_5.png create mode 100644 modules/dnn/tutorials/images/space_shuttle.jpg create mode 100644 modules/dnn/tutorials/tutorial_dnn_build.markdown create mode 100644 modules/dnn/tutorials/tutorial_dnn_googlenet.markdown create mode 100644 modules/dnn/tutorials/tutorial_dnn_halide.markdown create mode 100644 modules/dnn/tutorials/tutorial_dnn_halide_scheduling.markdown diff --git a/modules/dnn/CMakeLists.txt b/modules/dnn/CMakeLists.txt new file mode 100644 index 0000000000..e283e4803b --- /dev/null +++ b/modules/dnn/CMakeLists.txt @@ -0,0 +1,84 @@ +if(WINRT) + ocv_module_disable(dnn) +endif() + +include(${OpenCV_SOURCE_DIR}/cmake/OpenCVFindLibProtobuf.cmake) +if(NOT Protobuf_FOUND) + ocv_module_disable(opencv_dnn) +endif() + +set(the_description "Deep neural network module. It allows to load models from different frameworks and to make forward pass") + +ocv_add_module(dnn opencv_core opencv_imgproc WRAP python matlab) +ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-shadow -Wno-parentheses -Wmaybe-uninitialized -Wsign-promo + -Wmissing-declarations -Wmissing-prototypes +) +ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4701 /wd4100) + +if(MSVC) + add_definitions( -D_CRT_SECURE_NO_WARNINGS=1 ) + ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4244 /wd4267 /wd4018 /wd4355 /wd4800 /wd4251 /wd4996 /wd4146 + /wd4305 /wd4127 /wd4100 /wd4512 /wd4125 /wd4389 /wd4510 /wd4610 + /wd4702 /wd4456 /wd4457 /wd4065 /wd4310 /wd4661 /wd4506 + ) +else() + ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-deprecated -Wmissing-prototypes -Wmissing-declarations -Wshadow + -Wunused-parameter -Wunused-local-typedefs -Wsign-compare -Wsign-promo + -Wundef -Wtautological-undefined-compare -Wignored-qualifiers -Wextra + -Wunused-function -Wunused-const-variable -Wdeprecated-declarations + ) +endif() + +if(APPLE_FRAMEWORK) + ocv_warnings_disable(CMAKE_CXX_FLAGS -Wshorten-64-to-32) +endif() + +if(ANDROID) + add_definitions(-DDISABLE_POSIX_MEMALIGN -DTH_DISABLE_HEAP_TRACKING) +endif() + +#supress warnings in autogenerated caffe.pb.* files +add_definitions(-DHAVE_PROTOBUF=1) +ocv_warnings_disable(CMAKE_CXX_FLAGS + -Wunused-parameter -Wundef -Wignored-qualifiers -Wno-enum-compare + -Wdeprecated-declarations + /wd4125 /wd4267 /wd4127 /wd4244 /wd4512 /wd4702 + /wd4456 /wd4510 /wd4610 /wd4800 + -wd858 -wd2196 +) + +if(PROTOBUF_UPDATE_FILES) + file(GLOB proto_files src/tensorflow/*.proto) + list(APPEND proto_files src/caffe/caffe.proto) + PROTOBUF_GENERATE_CPP(Protobuf_HDRS Protobuf_SRCS ${proto_files}) +else() + file(GLOB fw_srcs ${CMAKE_CURRENT_SOURCE_DIR}/misc/tensorflow/*.cc) + file(GLOB fw_hdrs ${CMAKE_CURRENT_SOURCE_DIR}/misc/tensorflow/*.h) + list(APPEND fw_srcs ${CMAKE_CURRENT_SOURCE_DIR}/misc/caffe/caffe.pb.cc) + list(APPEND fw_hdrs ${CMAKE_CURRENT_SOURCE_DIR}/misc/caffe/caffe.pb.h) + list(APPEND Protobuf_SRCS ${fw_srcs}) + list(APPEND Protobuf_HDRS ${fw_hdrs}) + list(APPEND Protobuf_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/misc/caffe) + list(APPEND Protobuf_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/misc/tensorflow) +endif() + +ocv_source_group("Src\\protobuf" FILES ${Protobuf_SRCS} ${Protobuf_HDRS}) +ocv_module_include_directories(include ${Protobuf_INCLUDE_DIRS}) + +ocv_glob_module_sources(${Protobuf_SRCS} ${Protobuf_HDRS} ${CBLAS_H_PROXY_PATH}) +ocv_create_module(${Protobuf_LIBRARIES} ${LAPACK_LIBRARIES}) +ocv_add_samples() +ocv_add_accuracy_tests() +ocv_add_perf_tests() + +# ---------------------------------------------------------------------------- +# Torch7 importer of blobs and models, produced by Torch.nn module +# ---------------------------------------------------------------------------- +OCV_OPTION(${the_module}_BUILD_TORCH_IMPORTER "Build Torch model importer" ON) +if(${the_module}_BUILD_TORCH_IMPORTER) + message(STATUS "Torch importer has been enabled. To run the tests you have to install Torch " + "('th' executable should be available) " + "and generate testdata using opencv_extra/testdata/dnn/generate_torch_models.py script.") + add_definitions(-DENABLE_TORCH_IMPORTER=1) + ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4702 /wd4127 /wd4267) #supress warnings in original torch files +endif() diff --git a/modules/dnn/README.md b/modules/dnn/README.md new file mode 100644 index 0000000000..6e7e9c408a --- /dev/null +++ b/modules/dnn/README.md @@ -0,0 +1,2 @@ +Deep Neural Network module +========================== \ No newline at end of file diff --git a/modules/dnn/include/opencv2/dnn.hpp b/modules/dnn/include/opencv2/dnn.hpp new file mode 100644 index 0000000000..37be989263 --- /dev/null +++ b/modules/dnn/include/opencv2/dnn.hpp @@ -0,0 +1,64 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_HPP__ +#define __OPENCV_DNN_HPP__ + +// This is an umbrealla header to include into you project. +// We are free to change headers layout in dnn subfolder, so please include +// this header for future compartibility + + +/** @defgroup dnn Deep Neural Network module + @{ + This module contains: + - API for new layers creation, layers are building bricks of neural networks; + - set of built-in most-useful Layers; + - API to constuct and modify comprehensive neural networks from layers; + - functionality for loading serialized networks models from differnet frameworks. + + Functionality of this module is designed only for forward pass computations (i. e. network testing). + A network training is in principle not supported. + @} +*/ +#include + +#endif /* __OPENCV_DNN_HPP__ */ diff --git a/modules/dnn/include/opencv2/dnn/all_layers.hpp b/modules/dnn/include/opencv2/dnn/all_layers.hpp new file mode 100644 index 0000000000..a953e813c2 --- /dev/null +++ b/modules/dnn/include/opencv2/dnn/all_layers.hpp @@ -0,0 +1,471 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_DNN_ALL_LAYERS_HPP__ +#define __OPENCV_DNN_DNN_ALL_LAYERS_HPP__ +#include + +namespace cv +{ +namespace dnn +{ +//! @addtogroup dnn +//! @{ + +/** @defgroup dnnLayerList Partial List of Implemented Layers + @{ + This subsection of dnn module contains information about bult-in layers and their descriptions. + + Classes listed here, in fact, provides C++ API for creating intances of bult-in layers. + In addition to this way of layers instantiation, there is a more common factory API (see @ref dnnLayerFactory), it allows to create layers dynamically (by name) and register new ones. + You can use both API, but factory API is less convinient for native C++ programming and basically designed for use inside importers (see @ref Importer, @ref createCaffeImporter(), @ref createTorchImporter()). + + Bult-in layers partially reproduce functionality of corresponding Caffe and Torch7 layers. + In partuclar, the following layers and Caffe @ref Importer were tested to reproduce Caffe functionality: + - Convolution + - Deconvolution + - Pooling + - InnerProduct + - TanH, ReLU, Sigmoid, BNLL, Power, AbsVal + - Softmax + - Reshape, Flatten, Slice, Split + - LRN + - MVN + - Dropout (since it does nothing on forward pass -)) +*/ + + class CV_EXPORTS BlankLayer : public Layer + { + public: + static Ptr create(const LayerParams ¶ms); + }; + + //! LSTM recurrent layer + class CV_EXPORTS LSTMLayer : public Layer + { + public: + /** Creates instance of LSTM layer */ + static Ptr create(const LayerParams& params); + + /** Set trained weights for LSTM layer. + LSTM behavior on each step is defined by current input, previous output, previous cell state and learned weights. + + Let @f$x_t@f$ be current input, @f$h_t@f$ be current output, @f$c_t@f$ be current state. + Than current output and current cell state is computed as follows: + @f{eqnarray*}{ + h_t &= o_t \odot tanh(c_t), \\ + c_t &= f_t \odot c_{t-1} + i_t \odot g_t, \\ + @f} + where @f$\odot@f$ is per-element multiply operation and @f$i_t, f_t, o_t, g_t@f$ is internal gates that are computed using learned wights. + + Gates are computed as follows: + @f{eqnarray*}{ + i_t &= sigmoid&(W_{xi} x_t + W_{hi} h_{t-1} + b_i), \\ + f_t &= sigmoid&(W_{xf} x_t + W_{hf} h_{t-1} + b_f), \\ + o_t &= sigmoid&(W_{xo} x_t + W_{ho} h_{t-1} + b_o), \\ + g_t &= tanh &(W_{xg} x_t + W_{hg} h_{t-1} + b_g), \\ + @f} + where @f$W_{x?}@f$, @f$W_{h?}@f$ and @f$b_{?}@f$ are learned weights represented as matrices: + @f$W_{x?} \in R^{N_h \times N_x}@f$, @f$W_{h?} \in R^{N_h \times N_h}@f$, @f$b_? \in R^{N_h}@f$. + + For simplicity and performance purposes we use @f$ W_x = [W_{xi}; W_{xf}; W_{xo}, W_{xg}] @f$ + (i.e. @f$W_x@f$ is vertical contacentaion of @f$ W_{x?} @f$), @f$ W_x \in R^{4N_h \times N_x} @f$. + The same for @f$ W_h = [W_{hi}; W_{hf}; W_{ho}, W_{hg}], W_h \in R^{4N_h \times N_h} @f$ + and for @f$ b = [b_i; b_f, b_o, b_g]@f$, @f$b \in R^{4N_h} @f$. + + @param Wh is matrix defining how previous output is transformed to internal gates (i.e. according to abovemtioned notation is @f$ W_h @f$) + @param Wx is matrix defining how current input is transformed to internal gates (i.e. according to abovemtioned notation is @f$ W_x @f$) + @param b is bias vector (i.e. according to abovemtioned notation is @f$ b @f$) + */ + virtual void setWeights(const Mat &Wh, const Mat &Wx, const Mat &b) = 0; + + /** @brief Specifies shape of output blob which will be [[`T`], `N`] + @p outTailShape. + * @details If this parameter is empty or unset then @p outTailShape = [`Wh`.size(0)] will be used, + * where `Wh` is parameter from setWeights(). + */ + virtual void setOutShape(const MatShape &outTailShape = MatShape()) = 0; + + /** @brief Specifies either interpet first dimension of input blob as timestamp dimenion either as sample. + * + * If flag is set to true then shape of input blob will be interpeted as [`T`, `N`, `[data dims]`] where `T` specifies number of timpestamps, `N` is number of independent streams. + * In this case each forward() call will iterate through `T` timestamps and update layer's state `T` times. + * + * If flag is set to false then shape of input blob will be interpeted as [`N`, `[data dims]`]. + * In this case each forward() call will make one iteration and produce one timestamp with shape [`N`, `[out dims]`]. + */ + virtual void setUseTimstampsDim(bool use = true) = 0; + + /** @brief If this flag is set to true then layer will produce @f$ c_t @f$ as second output. + * @details Shape of the second output is the same as first output. + */ + virtual void setProduceCellOutput(bool produce = false) = 0; + + /* In common case it use single input with @f$x_t@f$ values to compute output(s) @f$h_t@f$ (and @f$c_t@f$). + * @param input should contain packed values @f$x_t@f$ + * @param output contains computed outputs: @f$h_t@f$ (and @f$c_t@f$ if setProduceCellOutput() flag was set to true). + * + * If setUseTimstampsDim() is set to true then @p input[0] should has at least two dimensions with the following shape: [`T`, `N`, `[data dims]`], + * where `T` specifies number of timpestamps, `N` is number of independent streams (i.e. @f$ x_{t_0 + t}^{stream} @f$ is stored inside @p input[0][t, stream, ...]). + * + * If setUseTimstampsDim() is set to fase then @p input[0] should contain single timestamp, its shape should has form [`N`, `[data dims]`] with at least one dimension. + * (i.e. @f$ x_{t}^{stream} @f$ is stored inside @p input[0][stream, ...]). + */ + + int inputNameToIndex(String inputName); + int outputNameToIndex(String outputName); + }; + + //! Classical recurrent layer + class CV_EXPORTS RNNLayer : public Layer + { + public: + /** Creates instance of RNNLayer */ + static Ptr create(const LayerParams& params); + + /** Setups learned weights. + + Recurrent-layer behavior on each step is defined by current input @f$ x_t @f$, previous state @f$ h_t @f$ and learned weights as follows: + @f{eqnarray*}{ + h_t &= tanh&(W_{hh} h_{t-1} + W_{xh} x_t + b_h), \\ + o_t &= tanh&(W_{ho} h_t + b_o), + @f} + + @param Wxh is @f$ W_{xh} @f$ matrix + @param bh is @f$ b_{h} @f$ vector + @param Whh is @f$ W_{hh} @f$ matrix + @param Who is @f$ W_{xo} @f$ matrix + @param bo is @f$ b_{o} @f$ vector + */ + virtual void setWeights(const Mat &Wxh, const Mat &bh, const Mat &Whh, const Mat &Who, const Mat &bo) = 0; + + /** @brief If this flag is set to true then layer will produce @f$ h_t @f$ as second output. + * @details Shape of the second output is the same as first output. + */ + virtual void setProduceHiddenOutput(bool produce = false) = 0; + + /** Accepts two inputs @f$x_t@f$ and @f$h_{t-1}@f$ and compute two outputs @f$o_t@f$ and @f$h_t@f$. + + @param input should contain packed input @f$x_t@f$. + @param output should contain output @f$o_t@f$ (and @f$h_t@f$ if setProduceHiddenOutput() is set to true). + + @p input[0] should have shape [`T`, `N`, `data_dims`] where `T` and `N` is number of timestamps and number of independent samples of @f$x_t@f$ respectively. + + @p output[0] will have shape [`T`, `N`, @f$N_o@f$], where @f$N_o@f$ is number of rows in @f$ W_{xo} @f$ matrix. + + If setProduceHiddenOutput() is set to true then @p output[1] will contain a Mat with shape [`T`, `N`, @f$N_h@f$], where @f$N_h@f$ is number of rows in @f$ W_{hh} @f$ matrix. + */ + }; + + class CV_EXPORTS BaseConvolutionLayer : public Layer + { + public: + Size kernel, stride, pad, dilation, adjustPad; + String padMode; + }; + + class CV_EXPORTS ActivationLayer; + class CV_EXPORTS BatchNormLayer; + + class CV_EXPORTS ConvolutionLayer : public BaseConvolutionLayer + { + public: + virtual bool setActivation(const Ptr& layer) = 0; + virtual bool setBatchNorm(const Ptr& layer) = 0; + + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS DeconvolutionLayer : public BaseConvolutionLayer + { + public: + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS LRNLayer : public Layer + { + public: + enum Type + { + CHANNEL_NRM, + SPATIAL_NRM + }; + int type; + + int size; + float alpha, beta, bias; + bool normBySize; + + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS PoolingLayer : public Layer + { + public: + enum Type + { + MAX, + AVE, + STOCHASTIC + }; + + int type; + Size kernel, stride, pad; + bool globalPooling; + bool computeMaxIdx; + String padMode; + + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS SoftmaxLayer : public Layer + { + public: + bool logSoftMax; + + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS InnerProductLayer : public Layer + { + public: + int axis; + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS MVNLayer : public Layer + { + public: + float eps; + bool normVariance, acrossChannels; + + static Ptr create(const LayerParams& params); + }; + + /* Reshaping */ + + class CV_EXPORTS ReshapeLayer : public Layer + { + public: + MatShape newShapeDesc; + Range newShapeRange; + + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS FlattenLayer : public Layer + { + public: + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS ConcatLayer : public Layer + { + public: + int axis; + + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS SplitLayer : public Layer + { + public: + int outputsCount; //!< Number of copies that will be produced (is ignored when negative). + + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS SliceLayer : public Layer + { + public: + int axis; + std::vector sliceIndices; + + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS PermuteLayer : public Layer + { + public: + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS PaddingLayer : public Layer + { + public: + static Ptr create(const LayerParams& params); + }; + + /* Activations */ + class CV_EXPORTS ActivationLayer : public Layer + { + public: + virtual void forwardSlice(const float* src, float* dst, int len, + size_t outPlaneSize, int cn0, int cn1) const = 0; + }; + + class CV_EXPORTS ReLULayer : public ActivationLayer + { + public: + float negativeSlope; + + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS ChannelsPReLULayer : public ActivationLayer + { + public: + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS TanHLayer : public ActivationLayer + { + public: + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS SigmoidLayer : public ActivationLayer + { + public: + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS BNLLLayer : public ActivationLayer + { + public: + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS AbsLayer : public ActivationLayer + { + public: + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS PowerLayer : public ActivationLayer + { + public: + float power, scale, shift; + + static Ptr create(const LayerParams ¶ms); + }; + + /* Layers used in semantic segmentation */ + + class CV_EXPORTS CropLayer : public Layer + { + public: + int startAxis; + std::vector offset; + + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS EltwiseLayer : public Layer + { + public: + enum EltwiseOp + { + PROD = 0, + SUM = 1, + MAX = 2, + }; + + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS BatchNormLayer : public Layer + { + public: + bool hasWeights, hasBias; + float epsilon; + + virtual void getScaleShift(Mat& scale, Mat& shift) const = 0; + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS MaxUnpoolLayer : public Layer + { + public: + Size poolKernel; + Size poolPad; + Size poolStride; + + static Ptr create(const LayerParams ¶ms); + }; + + class CV_EXPORTS ScaleLayer : public Layer + { + public: + bool hasBias; + + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS ShiftLayer : public Layer + { + public: + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS PriorBoxLayer : public Layer + { + public: + static Ptr create(const LayerParams& params); + }; + + class CV_EXPORTS DetectionOutputLayer : public Layer + { + public: + static Ptr create(const LayerParams& params); + }; + + class NormalizeBBoxLayer : public Layer + { + public: + static Ptr create(const LayerParams& params); + }; + +//! @} +//! @} + +} +} +#endif diff --git a/modules/dnn/include/opencv2/dnn/dict.hpp b/modules/dnn/include/opencv2/dnn/dict.hpp new file mode 100644 index 0000000000..1096cc0ff2 --- /dev/null +++ b/modules/dnn/include/opencv2/dnn/dict.hpp @@ -0,0 +1,146 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_DNN_DICT_HPP__ +#define __OPENCV_DNN_DNN_DICT_HPP__ + +#include +#include +#include + +namespace cv +{ +namespace dnn +{ +//! @addtogroup dnn +//! @{ + +/** @brief This struct stores the scalar value (or array) of one of the following type: double, cv::String or int64. + * @todo Maybe int64 is useless because double type exactly stores at least 2^52 integers. + */ +struct DictValue +{ + DictValue(const DictValue &r); + DictValue(int64 i = 0) : type(Param::INT), pi(new AutoBuffer) { (*pi)[0] = i; } //!< Constructs integer scalar + DictValue(int i) : type(Param::INT), pi(new AutoBuffer) { (*pi)[0] = i; } //!< Constructs integer scalar + DictValue(unsigned p) : type(Param::INT), pi(new AutoBuffer) { (*pi)[0] = p; } //!< Constructs integer scalar + DictValue(double p) : type(Param::REAL), pd(new AutoBuffer) { (*pd)[0] = p; } //!< Constructs floating point scalar + DictValue(const String &s) : type(Param::STRING), ps(new AutoBuffer) { (*ps)[0] = s; } //!< Constructs string scalar + DictValue(const char *s) : type(Param::STRING), ps(new AutoBuffer) { (*ps)[0] = s; } //!< @overload + + template + static DictValue arrayInt(TypeIter begin, int size); //!< Constructs integer array + template + static DictValue arrayReal(TypeIter begin, int size); //!< Constructs floating point array + template + static DictValue arrayString(TypeIter begin, int size); //!< Constructs array of strings + + template + T get(int idx = -1) const; //!< Tries to convert array element with specified index to requested type and returns its. + + int size() const; + + bool isInt() const; + bool isString() const; + bool isReal() const; + + DictValue &operator=(const DictValue &r); + + friend std::ostream &operator<<(std::ostream &stream, const DictValue &dictv); + + ~DictValue(); + +private: + + int type; + + union + { + AutoBuffer *pi; + AutoBuffer *pd; + AutoBuffer *ps; + void *pv; + }; + + DictValue(int _type, void *_p) : type(_type), pv(_p) {} + void release(); +}; + +/** @brief This class implements name-value dictionary, values are instances of DictValue. */ +class CV_EXPORTS Dict +{ + typedef std::map _Dict; + _Dict dict; + +public: + + //! Checks a presence of the @p key in the dictionary. + bool has(const String &key) const; + + //! If the @p key in the dictionary then returns pointer to its value, else returns NULL. + DictValue *ptr(const String &key); + + /** @overload */ + const DictValue *ptr(const String &key) const; + + //! If the @p key in the dictionary then returns its value, else an error will be generated. + const DictValue &get(const String &key) const; + + /** @overload */ + template + T get(const String &key) const; + + //! If the @p key in the dictionary then returns its value, else returns @p defaultValue. + template + T get(const String &key, const T &defaultValue) const; + + //! Sets new @p value for the @p key, or adds new key-value pair into the dictionary. + template + const T &set(const String &key, const T &value); + + friend std::ostream &operator<<(std::ostream &stream, const Dict &dict); +}; + +//! @} +} +} + +#endif diff --git a/modules/dnn/include/opencv2/dnn/dnn.hpp b/modules/dnn/include/opencv2/dnn/dnn.hpp new file mode 100644 index 0000000000..7a85da78c2 --- /dev/null +++ b/modules/dnn/include/opencv2/dnn/dnn.hpp @@ -0,0 +1,655 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_DNN_HPP__ +#define __OPENCV_DNN_DNN_HPP__ + +#include +#include +#include + +namespace cv +{ +namespace dnn //! This namespace is used for dnn module functionlaity. +{ +//! @addtogroup dnn +//! @{ + + typedef std::vector MatShape; + + /** + * @brief Enum of computation backends supported by layers. + */ + enum Backend + { + DNN_BACKEND_DEFAULT, + DNN_BACKEND_HALIDE + }; + + /** + * @brief Enum of target devices for computations. + */ + enum Target + { + DNN_TARGET_CPU, + DNN_TARGET_OPENCL + }; + + /** @brief Initialize dnn module and built-in layers. + * + * This function automatically called on most of OpenCV builds, + * but you need to call it manually on some specific configurations (iOS for example). + */ + CV_EXPORTS_W void initModule(); + + /** @brief This class provides all data needed to initialize layer. + * + * It includes dictionary with scalar params (which can be readed by using Dict interface), + * blob params #blobs and optional meta information: #name and #type of layer instance. + */ + class CV_EXPORTS LayerParams : public Dict + { + public: + //TODO: Add ability to name blob params + std::vector blobs; //!< List of learned parameters stored as blobs. + + String name; //!< Name of the layer instance (optional, can be used internal purposes). + String type; //!< Type name which was used for creating layer by layer factory (optional). + }; + + /** + * @brief Derivatives of this class encapsulates functions of certain backends. + */ + class BackendNode + { + public: + BackendNode(int backendId); + + virtual ~BackendNode(); //!< Virtual destructor to make polymorphism. + + int backendId; //!< Backend identifier. + }; + + /** + * @brief Derivatives of this class wraps cv::Mat for different backends and targets. + */ + class BackendWrapper + { + public: + BackendWrapper(int backendId, int targetId); + + /** + * @brief Wrap cv::Mat for specific backend and target. + * @param[in] targetId Target identifier. + * @param[in] m cv::Mat for wrapping. + * + * Make CPU->GPU data transfer if it's require for the target. + */ + BackendWrapper(int targetId, const cv::Mat& m); + + /** + * @brief Make wrapper for reused cv::Mat. + * @param[in] base Wrapper of cv::Mat that will be reused. + * @param[in] shape Specific shape. + * + * Initialize wrapper from another one. It'll wrap the same host CPU + * memory and mustn't allocate memory on device(i.e. GPU). It might + * has different shape. Use in case of CPU memory reusing for reuse + * associented memory on device too. + */ + BackendWrapper(const Ptr& base, const MatShape& shape); + + virtual ~BackendWrapper(); //!< Virtual destructor to make polymorphism. + + /** + * @brief Transfer data to CPU host memory. + */ + virtual void copyToHost() = 0; + + int backendId; //!< Backend identifier. + int targetId; //!< Target identifier. + }; + + /** @brief This interface class allows to build new Layers - are building blocks of networks. + * + * Each class, derived from Layer, must implement allocate() methods to declare own outputs and forward() to compute outputs. + * Also before using the new layer into networks you must register your layer by using one of @ref dnnLayerFactory "LayerFactory" macros. + */ + class CV_EXPORTS_W Layer + { + public: + + //! List of learned parameters must be stored here to allow read them by using Net::getParam(). + CV_PROP_RW std::vector blobs; + + /** @brief Computes and sets internal parameters according to inputs, outputs and blobs. + * @param[in] input vector of already allocated input blobs + * @param[out] output vector of already allocated output blobs + * + * If this method is called after network has allocated all memory for input and output blobs + * and before inferencing. + */ + virtual void finalize(const std::vector &input, std::vector &output); + + /** @brief Given the @p input blobs, computes the output @p blobs. + * @param[in] input the input blobs. + * @param[out] output allocated output blobs, which will store results of the computation. + * @param[out] internals allocated internal blobs + */ + virtual void forward(std::vector &input, std::vector &output, std::vector &internals) = 0; + + /** @brief @overload */ + CV_WRAP void finalize(const std::vector &inputs, CV_OUT std::vector &outputs); + + /** @brief @overload */ + CV_WRAP std::vector finalize(const std::vector &inputs); + + /** @brief @overload */ + CV_WRAP void forward(const std::vector &inputs, CV_IN_OUT std::vector &outputs, + CV_IN_OUT std::vector &internals); + + /** @brief Allocates layer and computes output. */ + CV_WRAP void run(const std::vector &inputs, CV_OUT std::vector &outputs, + CV_IN_OUT std::vector &internals); + + /** @brief Returns index of input blob into the input array. + * @param inputName label of input blob + * + * Each layer input and output can be labeled to easily identify them using "%[.output_name]" notation. + * This method maps label of input blob to its index into input vector. + */ + virtual int inputNameToIndex(String inputName); + /** @brief Returns index of output blob in output array. + * @see inputNameToIndex() + */ + virtual int outputNameToIndex(String outputName); + + /** + * @brief Ask layer if it support specific backend for doing computations. + * @param[in] backendId computation backend identifier. + * @see Backend + */ + virtual bool supportBackend(int backendId); + + /** + * @brief Returns Halide backend node. + * @param[in] inputs Input Halide buffers. + * @see BackendNode, BackendWrapper + * + * Input buffers should be exactly the same that will be used in forward invocations. + * Despite we can use Halide::ImageParam based on input shape only, + * it helps prevent some memory management issues (if something wrong, + * Halide tests will be failed). + */ + virtual Ptr initHalide(const std::vector > &inputs); + + /** + * @brief Automatic Halide scheduling based on layer hyper-parameters. + * @param[in] node Backend node with Halide functions. + * @param[in] inputs Blobs that will be used in forward invocations. + * @param[in] outputs Blobs that will be used in forward invocations. + * @param[in] targetId Target identifier + * @see BackendNode, Target + * + * Layer don't use own Halide::Func members because we can have applied + * layers fusing. In this way the fused function should be scheduled. + */ + virtual void applyHalideScheduler(Ptr& node, + const std::vector &inputs, + const std::vector &outputs, + int targetId) const; + + /** + * @brief Implement layers fusing. + * @param[in] node Backend node of bottom layer. + * @see BackendNode + * + * Actual for graph-based backends. If layer attached successfully, + * returns non-empty cv::Ptr to node of the same backend. + * Fuse only over the last function. + */ + virtual Ptr tryAttach(const Ptr& node); + + virtual bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const; + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const {(void)inputs; (void)outputs; return 0;} + + CV_PROP String name; //!< Name of the layer instance, can be used for logging or other internal purposes. + CV_PROP String type; //!< Type name which was used for creating layer by layer factory. + + Layer(); + explicit Layer(const LayerParams ¶ms); //!< Initializes only #name, #type and #blobs fields. + void setParamsFrom(const LayerParams ¶ms); //!< Initializes only #name, #type and #blobs fields. + virtual ~Layer(); + }; + + /** @brief This class allows to create and manipulate comprehensive artificial neural networks. + * + * Neural network is presented as directed acyclic graph (DAG), where vertices are Layer instances, + * and edges specify relationships between layers inputs and outputs. + * + * Each network layer has unique integer id and unique string name inside its network. + * LayerId can store either layer name or layer id. + * + * This class supports reference counting of its instances, i. e. copies point to the same instance. + */ + class CV_EXPORTS_W_SIMPLE Net + { + public: + + CV_WRAP Net(); //!< Default constructor. + CV_WRAP ~Net(); //!< Destructor frees the net only if there aren't references to the net anymore. + + /** Returns true if there are no layers in the network. */ + CV_WRAP bool empty() const; + + /** @brief Adds new layer to the net. + * @param name unique name of the adding layer. + * @param type typename of the adding layer (type must be registered in LayerRegister). + * @param params parameters which will be used to initialize the creating layer. + * @returns unique identifier of created layer, or -1 if a failure will happen. + */ + int addLayer(const String &name, const String &type, LayerParams ¶ms); + /** @brief Adds new layer and connects its first input to the first output of previously added layer. + * @see addLayer() + */ + int addLayerToPrev(const String &name, const String &type, LayerParams ¶ms); + + /** @brief Converts string name of the layer to the integer identifier. + * @returns id of the layer, or -1 if the layer wasn't found. + */ + CV_WRAP int getLayerId(const String &layer); + + CV_WRAP std::vector getLayerNames() const; + + /** @brief Container for strings and integers. */ + typedef DictValue LayerId; + + /** @brief Returns pointer to layer with specified name which the network use. */ + CV_WRAP Ptr getLayer(LayerId layerId); + + /** @brief Returns pointers to input layers of specific layer. */ + CV_WRAP std::vector > getLayerInputs(LayerId layerId); + + /** @brief Delete layer for the network (not implemented yet) */ + CV_WRAP void deleteLayer(LayerId layer); + + /** @brief Connects output of the first layer to input of the second layer. + * @param outPin descriptor of the first layer output. + * @param inpPin descriptor of the second layer input. + * + * Descriptors have the following template <layer_name>[.input_number]: + * - the first part of the template layer_name is sting name of the added layer. + * If this part is empty then the network input pseudo layer will be used; + * - the second optional part of the template input_number + * is either number of the layer input, either label one. + * If this part is omitted then the first layer input will be used. + * + * @see setNetInputs(), Layer::inputNameToIndex(), Layer::outputNameToIndex() + */ + CV_WRAP void connect(String outPin, String inpPin); + + /** @brief Connects #@p outNum output of the first layer to #@p inNum input of the second layer. + * @param outLayerId identifier of the first layer + * @param inpLayerId identifier of the second layer + * @param outNum number of the first layer output + * @param inpNum number of the second layer input + */ + void connect(int outLayerId, int outNum, int inpLayerId, int inpNum); + + /** @brief Sets outputs names of the network input pseudo layer. + * + * Each net always has special own the network input pseudo layer with id=0. + * This layer stores the user blobs only and don't make any computations. + * In fact, this layer provides the only way to pass user data into the network. + * As any other layer, this layer can label its outputs and this function provides an easy way to do this. + */ + CV_WRAP void setInputsNames(const std::vector &inputBlobNames); + + /** @brief Runs forward pass to compute output of layer with name @p outputName. + * @param outputName name for layer which output is needed to get + * @return blob for first output of specified layer. + * @details By default runs forward pass for the whole network. + */ + CV_WRAP Mat forward(const String& outputName = String()); + + /** @brief Runs forward pass to compute output of layer with name @p outputName. + * @param outputBlobs contains all output blobs for specified layer. + * @param outputName name for layer which output is needed to get + * @details If @p outputName is empty, runs forward pass for the whole network. + */ + CV_WRAP void forward(std::vector& outputBlobs, const String& outputName = String()); + + /** @brief Runs forward pass to compute outputs of layers listed in @p outBlobNames. + * @param outputBlobs contains blobs for first outputs of specified layers. + * @param outBlobNames names for layers which outputs are needed to get + */ + CV_WRAP void forward(std::vector& outputBlobs, + const std::vector& outBlobNames); + + /** @brief Runs forward pass to compute outputs of layers listed in @p outBlobNames. + * @param outputBlobs contains all output blobs for each layer specified in @p outBlobNames. + * @param outBlobNames names for layers which outputs are needed to get + */ + CV_WRAP void forward(std::vector >& outputBlobs, + const std::vector& outBlobNames); + + //TODO: + /** @brief Optimized forward. + * @warning Not implemented yet. + * @details Makes forward only those layers which weren't changed after previous forward(). + */ + void forwardOpt(LayerId toLayer); + /** @overload */ + void forwardOpt(const std::vector &toLayers); + + /** + * @brief Compile Halide layers. + * @param[in] scheduler Path to YAML file with scheduling directives. + * @see setPreferableBackend + * + * Schedule layers that support Halide backend. Then compile them for + * specific target. For layers that not represented in scheduling file + * or if no manual scheduling used at all, automatic scheduling will be applied. + */ + void setHalideScheduler(const String& scheduler); + + /** + * @brief Ask network to use specific computation backend where it supported. + * @param[in] backendId backend identifier. + * @see Backend + */ + void setPreferableBackend(int backendId); + + /** + * @brief Ask network to make computations on specific target device. + * @param[in] targetId target identifier. + * @see Target + */ + void setPreferableTarget(int targetId); + + /** @brief Sets the new value for the layer output blob + * @param name descriptor of the updating layer output blob. + * @param blob new blob. + * @see connect(String, String) to know format of the descriptor. + * @note If updating blob is not empty then @p blob must have the same shape, + * because network reshaping is not implemented yet. + */ + CV_WRAP void setInput(const Mat &blob, const String& name = ""); + + /** @brief Sets the new value for the learned param of the layer. + * @param layer name or id of the layer. + * @param numParam index of the layer parameter in the Layer::blobs array. + * @param blob the new value. + * @see Layer::blobs + * @note If shape of the new blob differs from the previous shape, + * then the following forward pass may fail. + */ + CV_WRAP void setParam(LayerId layer, int numParam, const Mat &blob); + + /** @brief Returns parameter blob of the layer. + * @param layer name or id of the layer. + * @param numParam index of the layer parameter in the Layer::blobs array. + * @see Layer::blobs + */ + CV_WRAP Mat getParam(LayerId layer, int numParam = 0); + + /** @brief Returns indexes of layers with unconnected outputs. + */ + CV_WRAP std::vector getUnconnectedOutLayers() const; + /** @brief Returns input and output shapes for all layers in loaded model; + * preliminary inferencing isn't necessary. + * @param netInputShapes shapes for all input blobs in net input layer. + * @param layersIds output parameter for layer IDs. + * @param inLayersShapes output parameter for input layers shapes; + * order is the same as in layersIds + * @param outLayersShapes output parameter for output layers shapes; + * order is the same as in layersIds + */ + CV_WRAP void getLayersShapes(const std::vector& netInputShapes, + std::vector* layersIds, + std::vector >* inLayersShapes, + std::vector >* outLayersShapes) const; + + /** @overload */ + CV_WRAP void getLayersShapes(const MatShape& netInputShape, + std::vector* layersIds, + std::vector >* inLayersShapes, + std::vector >* outLayersShapes) const; + + /** @brief Returns input and output shapes for layer with specified + * id in loaded model; preliminary inferencing isn't necessary. + * @param netInputShape shape input blob in net input layer. + * @param layerId id for layer. + * @param inLayerShapes output parameter for input layers shapes; + * order is the same as in layersIds + * @param outLayerShapes output parameter for output layers shapes; + * order is the same as in layersIds + */ + CV_WRAP void getLayerShapes(const MatShape& netInputShape, + const int layerId, + std::vector* inLayerShapes, + std::vector* outLayerShapes) const; + + /** @overload */ + CV_WRAP void getLayerShapes(const std::vector& netInputShapes, + const int layerId, + std::vector* inLayerShapes, + std::vector* outLayerShapes) const; + /** @brief Computes FLOP for whole loaded model with specified input shapes. + * @param netInputShapes vector of shapes for all net inputs. + * @returns computed FLOP. + */ + CV_WRAP int64 getFLOPS(const std::vector& netInputShapes) const; + /** @overload */ + CV_WRAP int64 getFLOPS(const MatShape& netInputShape) const; + /** @overload */ + CV_WRAP int64 getFLOPS(const int layerId, + const std::vector& netInputShapes) const; + /** @overload */ + CV_WRAP int64 getFLOPS(const int layerId, + const MatShape& netInputShape) const; + + /** @brief Returns list of types for layer used in model. + * @param layersTypes output parameter for returning types. + */ + CV_WRAP void getLayerTypes(std::vector& layersTypes) const; + + /** @brief Returns count of layers of specified type. + * @param layerType type. + * @returns count of layers + */ + CV_WRAP int getLayersCount(const String& layerType) const; + + /** @brief Computes bytes number which are requered to store + * all weights and intermediate blobs for model. + * @param netInputShapes vector of shapes for all net inputs. + * @param weights output parameter to store resulting bytes for weights. + * @param blobs output parameter to store resulting bytes for intermediate blobs. + */ + CV_WRAP void getMemoryConsumption(const std::vector& netInputShapes, + size_t& weights, size_t& blobs) const; + /** @overload */ + CV_WRAP void getMemoryConsumption(const MatShape& netInputShape, + size_t& weights, size_t& blobs) const; + /** @overload */ + CV_WRAP void getMemoryConsumption(const int layerId, + const std::vector& netInputShapes, + size_t& weights, size_t& blobs) const; + /** @overload */ + CV_WRAP void getMemoryConsumption(const int layerId, + const MatShape& netInputShape, + size_t& weights, size_t& blobs) const; + + /** @brief Computes bytes number which are requered to store + * all weights and intermediate blobs for each layer. + * @param netInputShapes vector of shapes for all net inputs. + * @param layerIds output vector to save layer IDs. + * @param weights output parameter to store resulting bytes for weights. + * @param blobs output parameter to store resulting bytes for intermediate blobs. + */ + CV_WRAP void getMemoryConsumption(const std::vector& netInputShapes, + std::vector& layerIds, std::vector& weights, + std::vector& blobs) const; + /** @overload */ + CV_WRAP void getMemoryConsumption(const MatShape& netInputShape, + std::vector& layerIds, std::vector& weights, + std::vector& blobs) const; + private: + + struct Impl; + Ptr impl; + }; + + /** @brief Small interface class for loading trained serialized models of different dnn-frameworks. */ + class CV_EXPORTS_W Importer + { + public: + + /** @brief Adds loaded layers into the @p net and sets connections between them. */ + CV_WRAP virtual void populateNet(Net net) = 0; + + virtual ~Importer(); + }; + + /** @brief Creates the importer of Caffe framework network. + * @param prototxt path to the .prototxt file with text description of the network architecture. + * @param caffeModel path to the .caffemodel file with learned network. + * @returns Pointer to the created importer, NULL in failure cases. + */ + CV_EXPORTS_W Ptr createCaffeImporter(const String &prototxt, const String &caffeModel = String()); + + /** @brief Reads a network model stored in Caffe model files. + * @details This is shortcut consisting from createCaffeImporter and Net::populateNet calls. + */ + CV_EXPORTS_W Net readNetFromCaffe(const String &prototxt, const String &caffeModel = String()); + + /** @brief Reads a network model stored in Tensorflow model file. + * @details This is shortcut consisting from createTensorflowImporter and Net::populateNet calls. + */ + CV_EXPORTS_W Net readNetFromTensorflow(const String &model); + + /** @brief Reads a network model stored in Torch model file. + * @details This is shortcut consisting from createTorchImporter and Net::populateNet calls. + */ + CV_EXPORTS_W Net readNetFromTorch(const String &model, bool isBinary = true); + + /** @brief Creates the importer of TensorFlow framework network. + * @param model path to the .pb file with binary protobuf description of the network architecture. + * @returns Pointer to the created importer, NULL in failure cases. + */ + CV_EXPORTS Ptr createTensorflowImporter(const String &model); + + /** @brief Creates the importer of Torch7 framework network. + * @param filename path to the file, dumped from Torch by using torch.save() function. + * @param isBinary specifies whether the network was serialized in ascii mode or binary. + * @returns Pointer to the created importer, NULL in failure cases. + * + * @warning Torch7 importer is experimental now, you need explicitly set CMake `opencv_dnn_BUILD_TORCH_IMPORTER` flag to compile its. + * + * @note Ascii mode of Torch serializer is more preferable, because binary mode extensively use `long` type of C language, + * which has various bit-length on different systems. + * + * The loading file must contain serialized nn.Module object + * with importing network. Try to eliminate a custom objects from serialazing data to avoid importing errors. + * + * List of supported layers (i.e. object instances derived from Torch nn.Module class): + * - nn.Sequential + * - nn.Parallel + * - nn.Concat + * - nn.Linear + * - nn.SpatialConvolution + * - nn.SpatialMaxPooling, nn.SpatialAveragePooling + * - nn.ReLU, nn.TanH, nn.Sigmoid + * - nn.Reshape + * - nn.SoftMax, nn.LogSoftMax + * + * Also some equivalents of these classes from cunn, cudnn, and fbcunn may be successfully imported. + */ + CV_EXPORTS_W Ptr createTorchImporter(const String &filename, bool isBinary = true); + + /** @brief Loads blob which was serialized as torch.Tensor object of Torch7 framework. + * @warning This function has the same limitations as createTorchImporter(). + */ + CV_EXPORTS_W Mat readTorchBlob(const String &filename, bool isBinary = true); + /** @brief Creates 4-dimensional blob from image. Optionally resizes and crops @p image from center, + * subtract @p mean values, scales values by @p scalefactor, swap Blue and Red channels. + * @param image input image (with 1- or 3-channels). + * @param size spatial size for output image + * @param mean scalar with mean values which are subtracted from channels. Values are intended + * to be in (mean-R, mean-G, mean-B) order if @p image has BGR ordering and @p swapRB is true. + * @param scalefactor multiplier for @p image values. + * @param swapRB flag which indicates that swap first and last channels + * in 3-channel image is necessary. + * @details input image is resized so one side after resize is equal to corresponing + * dimension in @p size and another one is equal or larger. Then, crop from the center is performed. + * @returns 4-dimansional Mat with NCHW dimensions order. + */ + CV_EXPORTS_W Mat blobFromImage(const Mat& image, double scalefactor=1.0, const Size& size = Size(), + const Scalar& mean = Scalar(), bool swapRB=true); + /** @brief Creates 4-dimensional blob from series of images. Optionally resizes and + * crops @p images from center, subtract @p mean values, scales values by @p scalefactor, + * swap Blue and Red channels. + * @param images input images (all with 1- or 3-channels). + * @param size spatial size for output image + * @param mean scalar with mean values which are subtracted from channels. Values are intended + * to be in (mean-R, mean-G, mean-B) order if @p image has BGR ordering and @p swapRB is true. + * @param scalefactor multiplier for @p images values. + * @param swapRB flag which indicates that swap first and last channels + * in 3-channel image is necessary. + * @details input image is resized so one side after resize is equal to corresponing + * dimension in @p size and another one is equal or larger. Then, crop from the center is performed. + * @returns 4-dimansional Mat with NCHW dimensions order. + */ + CV_EXPORTS_W Mat blobFromImages(const std::vector& images, double scalefactor=1.0, + Size size = Size(), const Scalar& mean = Scalar(), bool swapRB=true); + +//! @} +} +} + +#include +#include + +#endif /* __OPENCV_DNN_DNN_HPP__ */ diff --git a/modules/dnn/include/opencv2/dnn/dnn.inl.hpp b/modules/dnn/include/opencv2/dnn/dnn.inl.hpp new file mode 100644 index 0000000000..8a3c72ee98 --- /dev/null +++ b/modules/dnn/include/opencv2/dnn/dnn.inl.hpp @@ -0,0 +1,357 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_DNN_INL_HPP__ +#define __OPENCV_DNN_DNN_INL_HPP__ + +#include + +namespace cv +{ +namespace dnn +{ + +template +DictValue DictValue::arrayInt(TypeIter begin, int size) +{ + DictValue res(Param::INT, new AutoBuffer(size)); + for (int j = 0; j < size; begin++, j++) + (*res.pi)[j] = *begin; + return res; +} + +template +DictValue DictValue::arrayReal(TypeIter begin, int size) +{ + DictValue res(Param::REAL, new AutoBuffer(size)); + for (int j = 0; j < size; begin++, j++) + (*res.pd)[j] = *begin; + return res; +} + +template +DictValue DictValue::arrayString(TypeIter begin, int size) +{ + DictValue res(Param::STRING, new AutoBuffer(size)); + for (int j = 0; j < size; begin++, j++) + (*res.ps)[j] = *begin; + return res; +} + +template<> +inline DictValue DictValue::get(int idx) const +{ + CV_Assert(idx == -1); + return *this; +} + +template<> +inline int64 DictValue::get(int idx) const +{ + CV_Assert((idx == -1 && size() == 1) || (idx >= 0 && idx < size())); + idx = (idx == -1) ? 0 : idx; + + if (type == Param::INT) + { + return (*pi)[idx]; + } + else if (type == Param::REAL) + { + double doubleValue = (*pd)[idx]; + + double fracpart, intpart; + fracpart = std::modf(doubleValue, &intpart); + CV_Assert(fracpart == 0.0); + + return (int64)doubleValue; + } + else + { + CV_Assert(isInt() || isReal()); + return 0; + } +} + +template<> +inline int DictValue::get(int idx) const +{ + return (int)get(idx); +} + +template<> +inline unsigned DictValue::get(int idx) const +{ + return (unsigned)get(idx); +} + +template<> +inline bool DictValue::get(int idx) const +{ + return (get(idx) != 0); +} + +template<> +inline double DictValue::get(int idx) const +{ + CV_Assert((idx == -1 && size() == 1) || (idx >= 0 && idx < size())); + idx = (idx == -1) ? 0 : idx; + + if (type == Param::REAL) + { + return (*pd)[idx]; + } + else if (type == Param::INT) + { + return (double)(*pi)[idx]; + } + else + { + CV_Assert(isReal() || isInt()); + return 0; + } +} + +template<> +inline float DictValue::get(int idx) const +{ + return (float)get(idx); +} + +template<> +inline String DictValue::get(int idx) const +{ + CV_Assert(isString()); + CV_Assert((idx == -1 && ps->size() == 1) || (idx >= 0 && idx < (int)ps->size())); + return (*ps)[(idx == -1) ? 0 : idx]; +} + +inline void DictValue::release() +{ + switch (type) + { + case Param::INT: + delete pi; + break; + case Param::STRING: + delete ps; + break; + case Param::REAL: + delete pd; + break; + } +} + +inline DictValue::~DictValue() +{ + release(); +} + +inline DictValue & DictValue::operator=(const DictValue &r) +{ + if (&r == this) + return *this; + + if (r.type == Param::INT) + { + AutoBuffer *tmp = new AutoBuffer(*r.pi); + release(); + pi = tmp; + } + else if (r.type == Param::STRING) + { + AutoBuffer *tmp = new AutoBuffer(*r.ps); + release(); + ps = tmp; + } + else if (r.type == Param::REAL) + { + AutoBuffer *tmp = new AutoBuffer(*r.pd); + release(); + pd = tmp; + } + + type = r.type; + + return *this; +} + +inline DictValue::DictValue(const DictValue &r) +{ + type = r.type; + + if (r.type == Param::INT) + pi = new AutoBuffer(*r.pi); + else if (r.type == Param::STRING) + ps = new AutoBuffer(*r.ps); + else if (r.type == Param::REAL) + pd = new AutoBuffer(*r.pd); +} + +inline bool DictValue::isString() const +{ + return (type == Param::STRING); +} + +inline bool DictValue::isInt() const +{ + return (type == Param::INT); +} + +inline bool DictValue::isReal() const +{ + return (type == Param::REAL || type == Param::INT); +} + +inline int DictValue::size() const +{ + switch (type) + { + case Param::INT: + return (int)pi->size(); + break; + case Param::STRING: + return (int)ps->size(); + break; + case Param::REAL: + return (int)pd->size(); + break; + default: + CV_Error(Error::StsInternal, ""); + return -1; + } +} + +inline std::ostream &operator<<(std::ostream &stream, const DictValue &dictv) +{ + int i; + + if (dictv.isInt()) + { + for (i = 0; i < dictv.size() - 1; i++) + stream << dictv.get(i) << ", "; + stream << dictv.get(i); + } + else if (dictv.isReal()) + { + for (i = 0; i < dictv.size() - 1; i++) + stream << dictv.get(i) << ", "; + stream << dictv.get(i); + } + else if (dictv.isString()) + { + for (i = 0; i < dictv.size() - 1; i++) + stream << "\"" << dictv.get(i) << "\", "; + stream << dictv.get(i); + } + + return stream; +} + +///////////////////////////////////////////////////////////////// + +inline bool Dict::has(const String &key) const +{ + return dict.count(key) != 0; +} + +inline DictValue *Dict::ptr(const String &key) +{ + _Dict::iterator i = dict.find(key); + return (i == dict.end()) ? NULL : &i->second; +} + +inline const DictValue *Dict::ptr(const String &key) const +{ + _Dict::const_iterator i = dict.find(key); + return (i == dict.end()) ? NULL : &i->second; +} + +inline const DictValue &Dict::get(const String &key) const +{ + _Dict::const_iterator i = dict.find(key); + if (i == dict.end()) + CV_Error(Error::StsObjectNotFound, "Required argument \"" + key + "\" not found into dictionary"); + return i->second; +} + +template +inline T Dict::get(const String &key) const +{ + return this->get(key).get(); +} + +template +inline T Dict::get(const String &key, const T &defaultValue) const +{ + _Dict::const_iterator i = dict.find(key); + + if (i != dict.end()) + return i->second.get(); + else + return defaultValue; +} + +template +inline const T &Dict::set(const String &key, const T &value) +{ + _Dict::iterator i = dict.find(key); + + if (i != dict.end()) + i->second = DictValue(value); + else + dict.insert(std::make_pair(key, DictValue(value))); + + return value; +} + +inline std::ostream &operator<<(std::ostream &stream, const Dict &dict) +{ + Dict::_Dict::const_iterator it; + for (it = dict.dict.begin(); it != dict.dict.end(); it++) + stream << it->first << " : " << it->second << "\n"; + + return stream; +} + +} +} + +#endif diff --git a/modules/dnn/include/opencv2/dnn/layer.hpp b/modules/dnn/include/opencv2/dnn/layer.hpp new file mode 100644 index 0000000000..af663dd3e1 --- /dev/null +++ b/modules/dnn/include/opencv2/dnn/layer.hpp @@ -0,0 +1,148 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_LAYER_HPP__ +#define __OPENCV_DNN_LAYER_HPP__ +#include + +namespace cv +{ +namespace dnn +{ +//! @addtogroup dnn +//! @{ +//! +//! @defgroup dnnLayerFactory Utilities for New Layers Registration +//! @{ + +/** @brief %Layer factory allows to create instances of registered layers. */ +class CV_EXPORTS LayerFactory +{ +public: + + //! Each Layer class must provide this function to the factory + typedef Ptr(*Constuctor)(LayerParams ¶ms); + + //! Registers the layer class with typename @p type and specified @p constructor. + static void registerLayer(const String &type, Constuctor constructor); + + //! Unregisters registered layer with specified type name. + static void unregisterLayer(const String &type); + + /** @brief Creates instance of registered layer. + * @param type type name of creating layer. + * @param params parameters which will be used for layer initialization. + */ + static Ptr createLayerInstance(const String &type, LayerParams& params); + +private: + LayerFactory(); + + struct Impl; + static Ptr impl(); +}; + +/** @brief Registers layer constructor in runtime. +* @param type string, containing type name of the layer. +* @param constuctorFunc pointer to the function of type LayerRegister::Constuctor, which creates the layer. +* @details This macros must be placed inside the function code. +*/ +#define REG_RUNTIME_LAYER_FUNC(type, constuctorFunc) \ + cv::dnn::LayerFactory::registerLayer(#type, constuctorFunc); + +/** @brief Registers layer class in runtime. + * @param type string, containing type name of the layer. + * @param class C++ class, derived from Layer. + * @details This macros must be placed inside the function code. + */ +#define REG_RUNTIME_LAYER_CLASS(type, class) \ + cv::dnn::LayerFactory::registerLayer(#type, _layerDynamicRegisterer); + +/** @brief Registers layer constructor on module load time. +* @param type string, containing type name of the layer. +* @param constuctorFunc pointer to the function of type LayerRegister::Constuctor, which creates the layer. +* @details This macros must be placed outside the function code. +*/ +#define REG_STATIC_LAYER_FUNC(type, constuctorFunc) \ +static cv::dnn::_LayerStaticRegisterer __LayerStaticRegisterer_##type(#type, constuctorFunc); + +/** @brief Registers layer class on module load time. + * @param type string, containing type name of the layer. + * @param class C++ class, derived from Layer. + * @details This macros must be placed outside the function code. + */ +#define REG_STATIC_LAYER_CLASS(type, class) \ +Ptr __LayerStaticRegisterer_func_##type(LayerParams ¶ms) \ + { return Ptr(new class(params)); } \ +static _LayerStaticRegisterer __LayerStaticRegisterer_##type(#type, __LayerStaticRegisterer_func_##type); + + +//! @} +//! @} + + +template +Ptr _layerDynamicRegisterer(LayerParams ¶ms) +{ + return Ptr(LayerClass::create(params)); +} + +//allows automatically register created layer on module load time +class _LayerStaticRegisterer +{ + String type; +public: + + _LayerStaticRegisterer(const String &layerType, LayerFactory::Constuctor layerConstuctor) + { + this->type = layerType; + LayerFactory::registerLayer(layerType, layerConstuctor); + } + + ~_LayerStaticRegisterer() + { + LayerFactory::unregisterLayer(type); + } +}; + +} +} +#endif diff --git a/modules/dnn/include/opencv2/dnn/shape_utils.hpp b/modules/dnn/include/opencv2/dnn/shape_utils.hpp new file mode 100644 index 0000000000..7ecc8dd067 --- /dev/null +++ b/modules/dnn/include/opencv2/dnn/shape_utils.hpp @@ -0,0 +1,195 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_DNN_SHAPE_UTILS_HPP__ +#define __OPENCV_DNN_DNN_SHAPE_UTILS_HPP__ + +#include +#include +#include + +namespace cv { +namespace dnn { + +//Useful shortcut +inline std::ostream &operator<< (std::ostream &s, cv::Range &r) +{ + return s << "[" << r.start << ", " << r.end << ")"; +} + +//Slicing + +struct _Range : public cv::Range +{ + _Range(const Range &r) : cv::Range(r) {} + _Range(int start, int size = 1) : cv::Range(start, start + size) {} +}; + +static inline Mat slice(const Mat &m, const _Range &r0) +{ + Range ranges[CV_MAX_DIM]; + for (int i = 1; i < m.dims; i++) + ranges[i] = Range::all(); + ranges[0] = r0; + return m(&ranges[0]); +} + +static inline Mat slice(const Mat &m, const _Range &r0, const _Range &r1) +{ + CV_Assert(m.dims >= 2); + Range ranges[CV_MAX_DIM]; + for (int i = 2; i < m.dims; i++) + ranges[i] = Range::all(); + ranges[0] = r0; + ranges[1] = r1; + return m(&ranges[0]); +} + +static inline Mat slice(const Mat &m, const _Range &r0, const _Range &r1, const _Range &r2) +{ + CV_Assert(m.dims >= 3); + Range ranges[CV_MAX_DIM]; + for (int i = 3; i < m.dims; i++) + ranges[i] = Range::all(); + ranges[0] = r0; + ranges[1] = r1; + ranges[2] = r2; + return m(&ranges[0]); +} + +static inline Mat slice(const Mat &m, const _Range &r0, const _Range &r1, const _Range &r2, const _Range &r3) +{ + CV_Assert(m.dims >= 4); + Range ranges[CV_MAX_DIM]; + for (int i = 4; i < m.dims; i++) + ranges[i] = Range::all(); + ranges[0] = r0; + ranges[1] = r1; + ranges[2] = r2; + ranges[3] = r3; + return m(&ranges[0]); +} + +static inline Mat getPlane(const Mat &m, int n, int cn) +{ + CV_Assert(m.dims > 2); + Range range[CV_MAX_DIM]; + int sz[CV_MAX_DIM]; + for(int i = 2; i < m.dims; i++) + { + sz[i-2] = m.size.p[i]; + range[i] = Range::all(); + } + range[0] = Range(n, n+1); + range[1] = Range(cn, cn+1); + return m(range).reshape(1, m.dims-2, sz); +} + +static inline MatShape shape(const int* dims, const int n = 4) +{ + MatShape shape; + shape.assign(dims, dims + n); + return shape; +} + +static inline MatShape shape(const Mat& mat) +{ + return shape(mat.size.p, mat.dims); +} + +namespace {inline bool is_neg(int i) { return i < 0; }} + +static inline MatShape shape(int a0, int a1=-1, int a2=-1, int a3=-1) +{ + int dims[] = {a0, a1, a2, a3}; + MatShape s = shape(dims); + s.erase(std::remove_if(s.begin(), s.end(), is_neg), s.end()); + return s; +} + +static inline int total(const MatShape& shape, int start = -1, int end = -1) +{ + if (start == -1) start = 0; + if (end == -1) end = shape.size(); + + if (shape.empty()) + return 0; + + int elems = 1; + CV_Assert(start < shape.size() && end <= shape.size() && + start <= end); + for(int i = start; i < end; i++) + { + elems *= shape[i]; + } + return elems; +} + +static inline MatShape concat(const MatShape& a, const MatShape& b) +{ + MatShape c = a; + c.insert(c.end(), b.begin(), b.end()); + + return c; +} + +inline void print(const MatShape& shape, const String& name = "") +{ + printf("%s: [", name.c_str()); + size_t i, n = shape.size(); + for( i = 0; i < n; i++ ) + printf(" %d", shape[i]); + printf(" ]\n"); +} + +inline int clamp(int ax, int dims) +{ + return ax < 0 ? ax + dims : ax; +} + +inline int clamp(int ax, const MatShape& shape) +{ + return clamp(ax, shape.size()); +} + +} +} +#endif diff --git a/modules/dnn/misc/caffe/caffe.pb.cc b/modules/dnn/misc/caffe/caffe.pb.cc new file mode 100644 index 0000000000..f866183110 --- /dev/null +++ b/modules/dnn/misc/caffe/caffe.pb.cc @@ -0,0 +1,53676 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: caffe.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "caffe.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace caffe { + +namespace { + +const ::google::protobuf::Descriptor* BlobShape_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BlobShape_reflection_ = NULL; +const ::google::protobuf::Descriptor* BlobProto_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BlobProto_reflection_ = NULL; +const ::google::protobuf::Descriptor* BlobProtoVector_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BlobProtoVector_reflection_ = NULL; +const ::google::protobuf::Descriptor* PermuteParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PermuteParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* NormalizeBBoxParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NormalizeBBoxParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* PriorBoxParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PriorBoxParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* PriorBoxParameter_CodeType_descriptor_ = NULL; +const ::google::protobuf::Descriptor* DetectionOutputParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DetectionOutputParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* Datum_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Datum_reflection_ = NULL; +const ::google::protobuf::Descriptor* FillerParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FillerParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* FillerParameter_VarianceNorm_descriptor_ = NULL; +const ::google::protobuf::Descriptor* NetParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NetParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* SolverParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SolverParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* SolverParameter_SolverMode_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* SolverParameter_SolverType_descriptor_ = NULL; +const ::google::protobuf::Descriptor* SolverState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SolverState_reflection_ = NULL; +const ::google::protobuf::Descriptor* NetState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NetState_reflection_ = NULL; +const ::google::protobuf::Descriptor* NetStateRule_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NetStateRule_reflection_ = NULL; +const ::google::protobuf::Descriptor* ParamSpec_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ParamSpec_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* ParamSpec_DimCheckMode_descriptor_ = NULL; +const ::google::protobuf::Descriptor* LayerParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LayerParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* TransformationParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TransformationParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* LossParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LossParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* LossParameter_NormalizationMode_descriptor_ = NULL; +const ::google::protobuf::Descriptor* AccuracyParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccuracyParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ArgMaxParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ArgMaxParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ConcatParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ConcatParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* BatchNormParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BatchNormParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* BiasParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BiasParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ContrastiveLossParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ContrastiveLossParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ConvolutionParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ConvolutionParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* ConvolutionParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* CropParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CropParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* DataParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DataParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* DataParameter_DB_descriptor_ = NULL; +const ::google::protobuf::Descriptor* NonMaximumSuppressionParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NonMaximumSuppressionParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* SaveOutputParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SaveOutputParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* DropoutParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DropoutParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* DummyDataParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DummyDataParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* EltwiseParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + EltwiseParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor_ = NULL; +const ::google::protobuf::Descriptor* ELUParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ELUParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* EmbedParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + EmbedParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ExpParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ExpParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* FlattenParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FlattenParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* HDF5DataParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + HDF5DataParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* HDF5OutputParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + HDF5OutputParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* HingeLossParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + HingeLossParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* HingeLossParameter_Norm_descriptor_ = NULL; +const ::google::protobuf::Descriptor* ImageDataParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ImageDataParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* InfogainLossParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InfogainLossParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* InnerProductParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InnerProductParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* InputParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InputParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* LogParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LogParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* LRNParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LRNParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* LRNParameter_NormRegion_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* LRNParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* MemoryDataParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + MemoryDataParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* MVNParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + MVNParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ParameterParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ParameterParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* PoolingParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PoolingParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* PoolingParameter_PoolMethod_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* PoolingParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* PowerParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PowerParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* PythonParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PythonParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* RecurrentParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RecurrentParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ReductionParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ReductionParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* ReductionParameter_ReductionOp_descriptor_ = NULL; +const ::google::protobuf::Descriptor* ReLUParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ReLUParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* ReLUParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* ReshapeParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ReshapeParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ScaleParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ScaleParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* SigmoidParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SigmoidParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* SigmoidParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* SliceParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SliceParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* SoftmaxParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SoftmaxParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* SoftmaxParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* TanHParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TanHParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* TanHParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* TileParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TileParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* ThresholdParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ThresholdParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* WindowDataParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + WindowDataParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* SPPParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SPPParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* SPPParameter_PoolMethod_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* SPPParameter_Engine_descriptor_ = NULL; +const ::google::protobuf::Descriptor* V1LayerParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + V1LayerParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* V1LayerParameter_LayerType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor_ = NULL; +const ::google::protobuf::Descriptor* V0LayerParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + V0LayerParameter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor_ = NULL; +const ::google::protobuf::Descriptor* PReLUParameter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PReLUParameter_reflection_ = NULL; +const ::google::protobuf::Descriptor* NormalizedBBox_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NormalizedBBox_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* Phase_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_caffe_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_caffe_2eproto() { + protobuf_AddDesc_caffe_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "caffe.proto"); + GOOGLE_CHECK(file != NULL); + BlobShape_descriptor_ = file->message_type(0); + static const int BlobShape_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobShape, dim_), + }; + BlobShape_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + BlobShape_descriptor_, + BlobShape::internal_default_instance(), + BlobShape_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobShape, _has_bits_), + -1, + -1, + sizeof(BlobShape), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobShape, _internal_metadata_)); + BlobProto_descriptor_ = file->message_type(1); + static const int BlobProto_offsets_[9] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, shape_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, diff_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, double_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, double_diff_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, num_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, channels_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, height_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, width_), + }; + BlobProto_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + BlobProto_descriptor_, + BlobProto::internal_default_instance(), + BlobProto_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, _has_bits_), + -1, + -1, + sizeof(BlobProto), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProto, _internal_metadata_)); + BlobProtoVector_descriptor_ = file->message_type(2); + static const int BlobProtoVector_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProtoVector, blobs_), + }; + BlobProtoVector_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + BlobProtoVector_descriptor_, + BlobProtoVector::internal_default_instance(), + BlobProtoVector_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProtoVector, _has_bits_), + -1, + -1, + sizeof(BlobProtoVector), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlobProtoVector, _internal_metadata_)); + PermuteParameter_descriptor_ = file->message_type(3); + static const int PermuteParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PermuteParameter, order_), + }; + PermuteParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + PermuteParameter_descriptor_, + PermuteParameter::internal_default_instance(), + PermuteParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PermuteParameter, _has_bits_), + -1, + -1, + sizeof(PermuteParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PermuteParameter, _internal_metadata_)); + NormalizeBBoxParameter_descriptor_ = file->message_type(4); + static const int NormalizeBBoxParameter_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizeBBoxParameter, across_spatial_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizeBBoxParameter, scale_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizeBBoxParameter, channel_shared_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizeBBoxParameter, eps_), + }; + NormalizeBBoxParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NormalizeBBoxParameter_descriptor_, + NormalizeBBoxParameter::internal_default_instance(), + NormalizeBBoxParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizeBBoxParameter, _has_bits_), + -1, + -1, + sizeof(NormalizeBBoxParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizeBBoxParameter, _internal_metadata_)); + PriorBoxParameter_descriptor_ = file->message_type(5); + static const int PriorBoxParameter_offsets_[13] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, min_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, max_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, aspect_ratio_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, flip_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, clip_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, variance_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, img_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, img_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, img_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, step_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, step_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, step_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, offset_), + }; + PriorBoxParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + PriorBoxParameter_descriptor_, + PriorBoxParameter::internal_default_instance(), + PriorBoxParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, _has_bits_), + -1, + -1, + sizeof(PriorBoxParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PriorBoxParameter, _internal_metadata_)); + PriorBoxParameter_CodeType_descriptor_ = PriorBoxParameter_descriptor_->enum_type(0); + DetectionOutputParameter_descriptor_ = file->message_type(6); + static const int DetectionOutputParameter_offsets_[9] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, num_classes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, share_location_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, background_label_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, nms_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, save_output_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, code_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, variance_encoded_in_target_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, keep_top_k_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, confidence_threshold_), + }; + DetectionOutputParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + DetectionOutputParameter_descriptor_, + DetectionOutputParameter::internal_default_instance(), + DetectionOutputParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, _has_bits_), + -1, + -1, + sizeof(DetectionOutputParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DetectionOutputParameter, _internal_metadata_)); + Datum_descriptor_ = file->message_type(7); + static const int Datum_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, channels_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, height_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, width_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, label_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, float_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, encoded_), + }; + Datum_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + Datum_descriptor_, + Datum::internal_default_instance(), + Datum_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, _has_bits_), + -1, + -1, + sizeof(Datum), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Datum, _internal_metadata_)); + FillerParameter_descriptor_ = file->message_type(8); + static const int FillerParameter_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, min_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, max_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, mean_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, std_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, sparse_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, variance_norm_), + }; + FillerParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + FillerParameter_descriptor_, + FillerParameter::internal_default_instance(), + FillerParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, _has_bits_), + -1, + -1, + sizeof(FillerParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FillerParameter, _internal_metadata_)); + FillerParameter_VarianceNorm_descriptor_ = FillerParameter_descriptor_->enum_type(0); + NetParameter_descriptor_ = file->message_type(9); + static const int NetParameter_offsets_[9] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, input_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, input_shape_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, input_dim_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, force_backward_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, debug_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, layer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, layers_), + }; + NetParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NetParameter_descriptor_, + NetParameter::internal_default_instance(), + NetParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, _has_bits_), + -1, + -1, + sizeof(NetParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetParameter, _internal_metadata_)); + SolverParameter_descriptor_ = file->message_type(10); + static const int SolverParameter_offsets_[40] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, net_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, net_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, train_net_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, test_net_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, train_net_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, test_net_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, train_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, test_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, test_iter_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, test_interval_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, test_compute_loss_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, test_initialization_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, base_lr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, display_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, average_loss_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, max_iter_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, iter_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, lr_policy_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, gamma_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, power_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, momentum_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, weight_decay_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, regularization_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, stepsize_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, stepvalue_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, clip_gradients_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, snapshot_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, snapshot_prefix_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, snapshot_diff_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, snapshot_format_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, solver_mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, device_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, random_seed_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, delta_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, momentum2_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, rms_decay_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, debug_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, snapshot_after_train_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, solver_type_), + }; + SolverParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + SolverParameter_descriptor_, + SolverParameter::internal_default_instance(), + SolverParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, _has_bits_), + -1, + -1, + sizeof(SolverParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverParameter, _internal_metadata_)); + SolverParameter_SnapshotFormat_descriptor_ = SolverParameter_descriptor_->enum_type(0); + SolverParameter_SolverMode_descriptor_ = SolverParameter_descriptor_->enum_type(1); + SolverParameter_SolverType_descriptor_ = SolverParameter_descriptor_->enum_type(2); + SolverState_descriptor_ = file->message_type(11); + static const int SolverState_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverState, iter_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverState, learned_net_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverState, history_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverState, current_step_), + }; + SolverState_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + SolverState_descriptor_, + SolverState::internal_default_instance(), + SolverState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverState, _has_bits_), + -1, + -1, + sizeof(SolverState), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SolverState, _internal_metadata_)); + NetState_descriptor_ = file->message_type(12); + static const int NetState_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetState, phase_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetState, level_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetState, stage_), + }; + NetState_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NetState_descriptor_, + NetState::internal_default_instance(), + NetState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetState, _has_bits_), + -1, + -1, + sizeof(NetState), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetState, _internal_metadata_)); + NetStateRule_descriptor_ = file->message_type(13); + static const int NetStateRule_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetStateRule, phase_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetStateRule, min_level_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetStateRule, max_level_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetStateRule, stage_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetStateRule, not_stage_), + }; + NetStateRule_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NetStateRule_descriptor_, + NetStateRule::internal_default_instance(), + NetStateRule_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetStateRule, _has_bits_), + -1, + -1, + sizeof(NetStateRule), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NetStateRule, _internal_metadata_)); + ParamSpec_descriptor_ = file->message_type(14); + static const int ParamSpec_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParamSpec, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParamSpec, share_mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParamSpec, lr_mult_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParamSpec, decay_mult_), + }; + ParamSpec_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ParamSpec_descriptor_, + ParamSpec::internal_default_instance(), + ParamSpec_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParamSpec, _has_bits_), + -1, + -1, + sizeof(ParamSpec), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParamSpec, _internal_metadata_)); + ParamSpec_DimCheckMode_descriptor_ = ParamSpec_descriptor_->enum_type(0); + LayerParameter_descriptor_ = file->message_type(15); + static const int LayerParameter_offsets_[62] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, bottom_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, top_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, phase_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, loss_weight_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, blobs_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, propagate_down_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, include_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, exclude_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, transform_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, accuracy_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, argmax_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, batch_norm_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, bias_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, concat_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, contrastive_loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, convolution_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, crop_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, detection_output_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, dropout_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, dummy_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, eltwise_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, elu_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, embed_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, exp_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, flatten_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, hdf5_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, hdf5_output_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, hinge_loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, image_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, infogain_loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, inner_product_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, input_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, log_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, lrn_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, memory_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, mvn_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, norm_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, permute_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, parameter_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, pooling_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, power_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, prelu_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, prior_box_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, python_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, recurrent_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, reduction_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, relu_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, reshape_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, scale_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, sigmoid_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, softmax_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, spp_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, slice_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, tanh_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, threshold_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, tile_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, window_data_param_), + }; + LayerParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + LayerParameter_descriptor_, + LayerParameter::internal_default_instance(), + LayerParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, _has_bits_), + -1, + -1, + sizeof(LayerParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LayerParameter, _internal_metadata_)); + TransformationParameter_descriptor_ = file->message_type(16); + static const int TransformationParameter_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, mirror_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, crop_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, mean_file_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, mean_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, force_color_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, force_gray_), + }; + TransformationParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + TransformationParameter_descriptor_, + TransformationParameter::internal_default_instance(), + TransformationParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, _has_bits_), + -1, + -1, + sizeof(TransformationParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransformationParameter, _internal_metadata_)); + LossParameter_descriptor_ = file->message_type(17); + static const int LossParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LossParameter, ignore_label_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LossParameter, normalization_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LossParameter, normalize_), + }; + LossParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + LossParameter_descriptor_, + LossParameter::internal_default_instance(), + LossParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LossParameter, _has_bits_), + -1, + -1, + sizeof(LossParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LossParameter, _internal_metadata_)); + LossParameter_NormalizationMode_descriptor_ = LossParameter_descriptor_->enum_type(0); + AccuracyParameter_descriptor_ = file->message_type(18); + static const int AccuracyParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccuracyParameter, top_k_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccuracyParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccuracyParameter, ignore_label_), + }; + AccuracyParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + AccuracyParameter_descriptor_, + AccuracyParameter::internal_default_instance(), + AccuracyParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccuracyParameter, _has_bits_), + -1, + -1, + sizeof(AccuracyParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccuracyParameter, _internal_metadata_)); + ArgMaxParameter_descriptor_ = file->message_type(19); + static const int ArgMaxParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArgMaxParameter, out_max_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArgMaxParameter, top_k_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArgMaxParameter, axis_), + }; + ArgMaxParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ArgMaxParameter_descriptor_, + ArgMaxParameter::internal_default_instance(), + ArgMaxParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArgMaxParameter, _has_bits_), + -1, + -1, + sizeof(ArgMaxParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ArgMaxParameter, _internal_metadata_)); + ConcatParameter_descriptor_ = file->message_type(20); + static const int ConcatParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConcatParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConcatParameter, concat_dim_), + }; + ConcatParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ConcatParameter_descriptor_, + ConcatParameter::internal_default_instance(), + ConcatParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConcatParameter, _has_bits_), + -1, + -1, + sizeof(ConcatParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConcatParameter, _internal_metadata_)); + BatchNormParameter_descriptor_ = file->message_type(21); + static const int BatchNormParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchNormParameter, use_global_stats_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchNormParameter, moving_average_fraction_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchNormParameter, eps_), + }; + BatchNormParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + BatchNormParameter_descriptor_, + BatchNormParameter::internal_default_instance(), + BatchNormParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchNormParameter, _has_bits_), + -1, + -1, + sizeof(BatchNormParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchNormParameter, _internal_metadata_)); + BiasParameter_descriptor_ = file->message_type(22); + static const int BiasParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BiasParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BiasParameter, num_axes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BiasParameter, filler_), + }; + BiasParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + BiasParameter_descriptor_, + BiasParameter::internal_default_instance(), + BiasParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BiasParameter, _has_bits_), + -1, + -1, + sizeof(BiasParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BiasParameter, _internal_metadata_)); + ContrastiveLossParameter_descriptor_ = file->message_type(23); + static const int ContrastiveLossParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContrastiveLossParameter, margin_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContrastiveLossParameter, legacy_version_), + }; + ContrastiveLossParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ContrastiveLossParameter_descriptor_, + ContrastiveLossParameter::internal_default_instance(), + ContrastiveLossParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContrastiveLossParameter, _has_bits_), + -1, + -1, + sizeof(ContrastiveLossParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContrastiveLossParameter, _internal_metadata_)); + ConvolutionParameter_descriptor_ = file->message_type(24); + static const int ConvolutionParameter_offsets_[18] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, num_output_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, bias_term_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, pad_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, kernel_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, stride_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, dilation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, pad_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, pad_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, kernel_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, kernel_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, stride_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, stride_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, group_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, weight_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, bias_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, engine_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, force_nd_im2col_), + }; + ConvolutionParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ConvolutionParameter_descriptor_, + ConvolutionParameter::internal_default_instance(), + ConvolutionParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, _has_bits_), + -1, + -1, + sizeof(ConvolutionParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvolutionParameter, _internal_metadata_)); + ConvolutionParameter_Engine_descriptor_ = ConvolutionParameter_descriptor_->enum_type(0); + CropParameter_descriptor_ = file->message_type(25); + static const int CropParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CropParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CropParameter, offset_), + }; + CropParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + CropParameter_descriptor_, + CropParameter::internal_default_instance(), + CropParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CropParameter, _has_bits_), + -1, + -1, + sizeof(CropParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CropParameter, _internal_metadata_)); + DataParameter_descriptor_ = file->message_type(26); + static const int DataParameter_offsets_[10] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, source_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, batch_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, rand_skip_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, backend_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, mean_file_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, crop_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, mirror_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, force_encoded_color_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, prefetch_), + }; + DataParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + DataParameter_descriptor_, + DataParameter::internal_default_instance(), + DataParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, _has_bits_), + -1, + -1, + sizeof(DataParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DataParameter, _internal_metadata_)); + DataParameter_DB_descriptor_ = DataParameter_descriptor_->enum_type(0); + NonMaximumSuppressionParameter_descriptor_ = file->message_type(27); + static const int NonMaximumSuppressionParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NonMaximumSuppressionParameter, nms_threshold_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NonMaximumSuppressionParameter, top_k_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NonMaximumSuppressionParameter, eta_), + }; + NonMaximumSuppressionParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NonMaximumSuppressionParameter_descriptor_, + NonMaximumSuppressionParameter::internal_default_instance(), + NonMaximumSuppressionParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NonMaximumSuppressionParameter, _has_bits_), + -1, + -1, + sizeof(NonMaximumSuppressionParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NonMaximumSuppressionParameter, _internal_metadata_)); + SaveOutputParameter_descriptor_ = file->message_type(28); + static const int SaveOutputParameter_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, output_directory_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, output_name_prefix_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, output_format_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, label_map_file_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, name_size_file_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, num_test_image_), + }; + SaveOutputParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + SaveOutputParameter_descriptor_, + SaveOutputParameter::internal_default_instance(), + SaveOutputParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, _has_bits_), + -1, + -1, + sizeof(SaveOutputParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaveOutputParameter, _internal_metadata_)); + DropoutParameter_descriptor_ = file->message_type(29); + static const int DropoutParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropoutParameter, dropout_ratio_), + }; + DropoutParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + DropoutParameter_descriptor_, + DropoutParameter::internal_default_instance(), + DropoutParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropoutParameter, _has_bits_), + -1, + -1, + sizeof(DropoutParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropoutParameter, _internal_metadata_)); + DummyDataParameter_descriptor_ = file->message_type(30); + static const int DummyDataParameter_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, data_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, shape_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, num_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, channels_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, height_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, width_), + }; + DummyDataParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + DummyDataParameter_descriptor_, + DummyDataParameter::internal_default_instance(), + DummyDataParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, _has_bits_), + -1, + -1, + sizeof(DummyDataParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DummyDataParameter, _internal_metadata_)); + EltwiseParameter_descriptor_ = file->message_type(31); + static const int EltwiseParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EltwiseParameter, operation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EltwiseParameter, coeff_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EltwiseParameter, stable_prod_grad_), + }; + EltwiseParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + EltwiseParameter_descriptor_, + EltwiseParameter::internal_default_instance(), + EltwiseParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EltwiseParameter, _has_bits_), + -1, + -1, + sizeof(EltwiseParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EltwiseParameter, _internal_metadata_)); + EltwiseParameter_EltwiseOp_descriptor_ = EltwiseParameter_descriptor_->enum_type(0); + ELUParameter_descriptor_ = file->message_type(32); + static const int ELUParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ELUParameter, alpha_), + }; + ELUParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ELUParameter_descriptor_, + ELUParameter::internal_default_instance(), + ELUParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ELUParameter, _has_bits_), + -1, + -1, + sizeof(ELUParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ELUParameter, _internal_metadata_)); + EmbedParameter_descriptor_ = file->message_type(33); + static const int EmbedParameter_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedParameter, num_output_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedParameter, input_dim_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedParameter, bias_term_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedParameter, weight_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedParameter, bias_filler_), + }; + EmbedParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + EmbedParameter_descriptor_, + EmbedParameter::internal_default_instance(), + EmbedParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedParameter, _has_bits_), + -1, + -1, + sizeof(EmbedParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedParameter, _internal_metadata_)); + ExpParameter_descriptor_ = file->message_type(34); + static const int ExpParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExpParameter, base_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExpParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExpParameter, shift_), + }; + ExpParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ExpParameter_descriptor_, + ExpParameter::internal_default_instance(), + ExpParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExpParameter, _has_bits_), + -1, + -1, + sizeof(ExpParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExpParameter, _internal_metadata_)); + FlattenParameter_descriptor_ = file->message_type(35); + static const int FlattenParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FlattenParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FlattenParameter, end_axis_), + }; + FlattenParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + FlattenParameter_descriptor_, + FlattenParameter::internal_default_instance(), + FlattenParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FlattenParameter, _has_bits_), + -1, + -1, + sizeof(FlattenParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FlattenParameter, _internal_metadata_)); + HDF5DataParameter_descriptor_ = file->message_type(36); + static const int HDF5DataParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5DataParameter, source_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5DataParameter, batch_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5DataParameter, shuffle_), + }; + HDF5DataParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + HDF5DataParameter_descriptor_, + HDF5DataParameter::internal_default_instance(), + HDF5DataParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5DataParameter, _has_bits_), + -1, + -1, + sizeof(HDF5DataParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5DataParameter, _internal_metadata_)); + HDF5OutputParameter_descriptor_ = file->message_type(37); + static const int HDF5OutputParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5OutputParameter, file_name_), + }; + HDF5OutputParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + HDF5OutputParameter_descriptor_, + HDF5OutputParameter::internal_default_instance(), + HDF5OutputParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5OutputParameter, _has_bits_), + -1, + -1, + sizeof(HDF5OutputParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HDF5OutputParameter, _internal_metadata_)); + HingeLossParameter_descriptor_ = file->message_type(38); + static const int HingeLossParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HingeLossParameter, norm_), + }; + HingeLossParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + HingeLossParameter_descriptor_, + HingeLossParameter::internal_default_instance(), + HingeLossParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HingeLossParameter, _has_bits_), + -1, + -1, + sizeof(HingeLossParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HingeLossParameter, _internal_metadata_)); + HingeLossParameter_Norm_descriptor_ = HingeLossParameter_descriptor_->enum_type(0); + ImageDataParameter_descriptor_ = file->message_type(39); + static const int ImageDataParameter_offsets_[12] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, source_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, batch_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, rand_skip_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, shuffle_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, new_height_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, new_width_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, is_color_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, mean_file_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, crop_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, mirror_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, root_folder_), + }; + ImageDataParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ImageDataParameter_descriptor_, + ImageDataParameter::internal_default_instance(), + ImageDataParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, _has_bits_), + -1, + -1, + sizeof(ImageDataParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ImageDataParameter, _internal_metadata_)); + InfogainLossParameter_descriptor_ = file->message_type(40); + static const int InfogainLossParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InfogainLossParameter, source_), + }; + InfogainLossParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + InfogainLossParameter_descriptor_, + InfogainLossParameter::internal_default_instance(), + InfogainLossParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InfogainLossParameter, _has_bits_), + -1, + -1, + sizeof(InfogainLossParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InfogainLossParameter, _internal_metadata_)); + InnerProductParameter_descriptor_ = file->message_type(41); + static const int InnerProductParameter_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, num_output_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, bias_term_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, weight_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, bias_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, transpose_), + }; + InnerProductParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + InnerProductParameter_descriptor_, + InnerProductParameter::internal_default_instance(), + InnerProductParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, _has_bits_), + -1, + -1, + sizeof(InnerProductParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InnerProductParameter, _internal_metadata_)); + InputParameter_descriptor_ = file->message_type(42); + static const int InputParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InputParameter, shape_), + }; + InputParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + InputParameter_descriptor_, + InputParameter::internal_default_instance(), + InputParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InputParameter, _has_bits_), + -1, + -1, + sizeof(InputParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InputParameter, _internal_metadata_)); + LogParameter_descriptor_ = file->message_type(43); + static const int LogParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogParameter, base_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogParameter, shift_), + }; + LogParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + LogParameter_descriptor_, + LogParameter::internal_default_instance(), + LogParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogParameter, _has_bits_), + -1, + -1, + sizeof(LogParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogParameter, _internal_metadata_)); + LRNParameter_descriptor_ = file->message_type(44); + static const int LRNParameter_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, local_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, alpha_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, beta_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, norm_region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, k_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, engine_), + }; + LRNParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + LRNParameter_descriptor_, + LRNParameter::internal_default_instance(), + LRNParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, _has_bits_), + -1, + -1, + sizeof(LRNParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LRNParameter, _internal_metadata_)); + LRNParameter_NormRegion_descriptor_ = LRNParameter_descriptor_->enum_type(0); + LRNParameter_Engine_descriptor_ = LRNParameter_descriptor_->enum_type(1); + MemoryDataParameter_descriptor_ = file->message_type(45); + static const int MemoryDataParameter_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemoryDataParameter, batch_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemoryDataParameter, channels_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemoryDataParameter, height_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemoryDataParameter, width_), + }; + MemoryDataParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + MemoryDataParameter_descriptor_, + MemoryDataParameter::internal_default_instance(), + MemoryDataParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemoryDataParameter, _has_bits_), + -1, + -1, + sizeof(MemoryDataParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemoryDataParameter, _internal_metadata_)); + MVNParameter_descriptor_ = file->message_type(46); + static const int MVNParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MVNParameter, normalize_variance_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MVNParameter, across_channels_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MVNParameter, eps_), + }; + MVNParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + MVNParameter_descriptor_, + MVNParameter::internal_default_instance(), + MVNParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MVNParameter, _has_bits_), + -1, + -1, + sizeof(MVNParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MVNParameter, _internal_metadata_)); + ParameterParameter_descriptor_ = file->message_type(47); + static const int ParameterParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParameterParameter, shape_), + }; + ParameterParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ParameterParameter_descriptor_, + ParameterParameter::internal_default_instance(), + ParameterParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParameterParameter, _has_bits_), + -1, + -1, + sizeof(ParameterParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParameterParameter, _internal_metadata_)); + PoolingParameter_descriptor_ = file->message_type(48); + static const int PoolingParameter_offsets_[12] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, pool_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, pad_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, pad_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, pad_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, kernel_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, kernel_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, kernel_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, stride_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, stride_h_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, stride_w_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, engine_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, global_pooling_), + }; + PoolingParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + PoolingParameter_descriptor_, + PoolingParameter::internal_default_instance(), + PoolingParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, _has_bits_), + -1, + -1, + sizeof(PoolingParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PoolingParameter, _internal_metadata_)); + PoolingParameter_PoolMethod_descriptor_ = PoolingParameter_descriptor_->enum_type(0); + PoolingParameter_Engine_descriptor_ = PoolingParameter_descriptor_->enum_type(1); + PowerParameter_descriptor_ = file->message_type(49); + static const int PowerParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PowerParameter, power_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PowerParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PowerParameter, shift_), + }; + PowerParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + PowerParameter_descriptor_, + PowerParameter::internal_default_instance(), + PowerParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PowerParameter, _has_bits_), + -1, + -1, + sizeof(PowerParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PowerParameter, _internal_metadata_)); + PythonParameter_descriptor_ = file->message_type(50); + static const int PythonParameter_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PythonParameter, module_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PythonParameter, layer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PythonParameter, param_str_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PythonParameter, share_in_parallel_), + }; + PythonParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + PythonParameter_descriptor_, + PythonParameter::internal_default_instance(), + PythonParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PythonParameter, _has_bits_), + -1, + -1, + sizeof(PythonParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PythonParameter, _internal_metadata_)); + RecurrentParameter_descriptor_ = file->message_type(51); + static const int RecurrentParameter_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecurrentParameter, num_output_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecurrentParameter, weight_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecurrentParameter, bias_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecurrentParameter, debug_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecurrentParameter, expose_hidden_), + }; + RecurrentParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + RecurrentParameter_descriptor_, + RecurrentParameter::internal_default_instance(), + RecurrentParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecurrentParameter, _has_bits_), + -1, + -1, + sizeof(RecurrentParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecurrentParameter, _internal_metadata_)); + ReductionParameter_descriptor_ = file->message_type(52); + static const int ReductionParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReductionParameter, operation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReductionParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReductionParameter, coeff_), + }; + ReductionParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ReductionParameter_descriptor_, + ReductionParameter::internal_default_instance(), + ReductionParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReductionParameter, _has_bits_), + -1, + -1, + sizeof(ReductionParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReductionParameter, _internal_metadata_)); + ReductionParameter_ReductionOp_descriptor_ = ReductionParameter_descriptor_->enum_type(0); + ReLUParameter_descriptor_ = file->message_type(53); + static const int ReLUParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReLUParameter, negative_slope_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReLUParameter, engine_), + }; + ReLUParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ReLUParameter_descriptor_, + ReLUParameter::internal_default_instance(), + ReLUParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReLUParameter, _has_bits_), + -1, + -1, + sizeof(ReLUParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReLUParameter, _internal_metadata_)); + ReLUParameter_Engine_descriptor_ = ReLUParameter_descriptor_->enum_type(0); + ReshapeParameter_descriptor_ = file->message_type(54); + static const int ReshapeParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReshapeParameter, shape_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReshapeParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReshapeParameter, num_axes_), + }; + ReshapeParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ReshapeParameter_descriptor_, + ReshapeParameter::internal_default_instance(), + ReshapeParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReshapeParameter, _has_bits_), + -1, + -1, + sizeof(ReshapeParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReshapeParameter, _internal_metadata_)); + ScaleParameter_descriptor_ = file->message_type(55); + static const int ScaleParameter_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScaleParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScaleParameter, num_axes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScaleParameter, filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScaleParameter, bias_term_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScaleParameter, bias_filler_), + }; + ScaleParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ScaleParameter_descriptor_, + ScaleParameter::internal_default_instance(), + ScaleParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScaleParameter, _has_bits_), + -1, + -1, + sizeof(ScaleParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScaleParameter, _internal_metadata_)); + SigmoidParameter_descriptor_ = file->message_type(56); + static const int SigmoidParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SigmoidParameter, engine_), + }; + SigmoidParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + SigmoidParameter_descriptor_, + SigmoidParameter::internal_default_instance(), + SigmoidParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SigmoidParameter, _has_bits_), + -1, + -1, + sizeof(SigmoidParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SigmoidParameter, _internal_metadata_)); + SigmoidParameter_Engine_descriptor_ = SigmoidParameter_descriptor_->enum_type(0); + SliceParameter_descriptor_ = file->message_type(57); + static const int SliceParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SliceParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SliceParameter, slice_point_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SliceParameter, slice_dim_), + }; + SliceParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + SliceParameter_descriptor_, + SliceParameter::internal_default_instance(), + SliceParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SliceParameter, _has_bits_), + -1, + -1, + sizeof(SliceParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SliceParameter, _internal_metadata_)); + SoftmaxParameter_descriptor_ = file->message_type(58); + static const int SoftmaxParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SoftmaxParameter, engine_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SoftmaxParameter, axis_), + }; + SoftmaxParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + SoftmaxParameter_descriptor_, + SoftmaxParameter::internal_default_instance(), + SoftmaxParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SoftmaxParameter, _has_bits_), + -1, + -1, + sizeof(SoftmaxParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SoftmaxParameter, _internal_metadata_)); + SoftmaxParameter_Engine_descriptor_ = SoftmaxParameter_descriptor_->enum_type(0); + TanHParameter_descriptor_ = file->message_type(59); + static const int TanHParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TanHParameter, engine_), + }; + TanHParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + TanHParameter_descriptor_, + TanHParameter::internal_default_instance(), + TanHParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TanHParameter, _has_bits_), + -1, + -1, + sizeof(TanHParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TanHParameter, _internal_metadata_)); + TanHParameter_Engine_descriptor_ = TanHParameter_descriptor_->enum_type(0); + TileParameter_descriptor_ = file->message_type(60); + static const int TileParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TileParameter, axis_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TileParameter, tiles_), + }; + TileParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + TileParameter_descriptor_, + TileParameter::internal_default_instance(), + TileParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TileParameter, _has_bits_), + -1, + -1, + sizeof(TileParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TileParameter, _internal_metadata_)); + ThresholdParameter_descriptor_ = file->message_type(61); + static const int ThresholdParameter_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ThresholdParameter, threshold_), + }; + ThresholdParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + ThresholdParameter_descriptor_, + ThresholdParameter::internal_default_instance(), + ThresholdParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ThresholdParameter, _has_bits_), + -1, + -1, + sizeof(ThresholdParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ThresholdParameter, _internal_metadata_)); + WindowDataParameter_descriptor_ = file->message_type(62); + static const int WindowDataParameter_offsets_[13] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, source_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, mean_file_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, batch_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, crop_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, mirror_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, fg_threshold_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, bg_threshold_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, fg_fraction_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, context_pad_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, crop_mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, cache_images_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, root_folder_), + }; + WindowDataParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + WindowDataParameter_descriptor_, + WindowDataParameter::internal_default_instance(), + WindowDataParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, _has_bits_), + -1, + -1, + sizeof(WindowDataParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WindowDataParameter, _internal_metadata_)); + SPPParameter_descriptor_ = file->message_type(63); + static const int SPPParameter_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SPPParameter, pyramid_height_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SPPParameter, pool_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SPPParameter, engine_), + }; + SPPParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + SPPParameter_descriptor_, + SPPParameter::internal_default_instance(), + SPPParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SPPParameter, _has_bits_), + -1, + -1, + sizeof(SPPParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SPPParameter, _internal_metadata_)); + SPPParameter_PoolMethod_descriptor_ = SPPParameter_descriptor_->enum_type(0); + SPPParameter_Engine_descriptor_ = SPPParameter_descriptor_->enum_type(1); + V1LayerParameter_descriptor_ = file->message_type(64); + static const int V1LayerParameter_offsets_[43] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, bottom_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, top_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, include_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, exclude_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, blobs_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, blob_share_mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, blobs_lr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, weight_decay_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, loss_weight_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, accuracy_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, argmax_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, concat_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, contrastive_loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, convolution_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, dropout_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, dummy_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, eltwise_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, exp_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, hdf5_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, hdf5_output_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, hinge_loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, image_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, infogain_loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, inner_product_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, lrn_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, memory_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, mvn_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, pooling_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, power_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, relu_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, sigmoid_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, softmax_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, slice_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, tanh_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, threshold_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, window_data_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, transform_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, loss_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, layer_), + }; + V1LayerParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + V1LayerParameter_descriptor_, + V1LayerParameter::internal_default_instance(), + V1LayerParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, _has_bits_), + -1, + -1, + sizeof(V1LayerParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V1LayerParameter, _internal_metadata_)); + V1LayerParameter_LayerType_descriptor_ = V1LayerParameter_descriptor_->enum_type(0); + V1LayerParameter_DimCheckMode_descriptor_ = V1LayerParameter_descriptor_->enum_type(1); + V0LayerParameter_descriptor_ = file->message_type(65); + static const int V0LayerParameter_offsets_[38] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, num_output_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, biasterm_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, weight_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, bias_filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, pad_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, kernelsize_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, group_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, stride_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, pool_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, dropout_ratio_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, local_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, alpha_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, beta_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, k_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, source_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, scale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, meanfile_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, batchsize_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, cropsize_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, mirror_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, blobs_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, blobs_lr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, weight_decay_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, rand_skip_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, det_fg_threshold_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, det_bg_threshold_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, det_fg_fraction_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, det_context_pad_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, det_crop_mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, new_num_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, new_channels_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, new_height_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, new_width_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, shuffle_images_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, concat_dim_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, hdf5_output_param_), + }; + V0LayerParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + V0LayerParameter_descriptor_, + V0LayerParameter::internal_default_instance(), + V0LayerParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, _has_bits_), + -1, + -1, + sizeof(V0LayerParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(V0LayerParameter, _internal_metadata_)); + V0LayerParameter_PoolMethod_descriptor_ = V0LayerParameter_descriptor_->enum_type(0); + PReLUParameter_descriptor_ = file->message_type(66); + static const int PReLUParameter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PReLUParameter, filler_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PReLUParameter, channel_shared_), + }; + PReLUParameter_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + PReLUParameter_descriptor_, + PReLUParameter::internal_default_instance(), + PReLUParameter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PReLUParameter, _has_bits_), + -1, + -1, + sizeof(PReLUParameter), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PReLUParameter, _internal_metadata_)); + NormalizedBBox_descriptor_ = file->message_type(67); + static const int NormalizedBBox_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, xmin_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, ymin_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, xmax_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, ymax_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, label_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, difficult_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, score_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, size_), + }; + NormalizedBBox_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NormalizedBBox_descriptor_, + NormalizedBBox::internal_default_instance(), + NormalizedBBox_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, _has_bits_), + -1, + -1, + sizeof(NormalizedBBox), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NormalizedBBox, _internal_metadata_)); + Phase_descriptor_ = file->enum_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_caffe_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BlobShape_descriptor_, BlobShape::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BlobProto_descriptor_, BlobProto::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BlobProtoVector_descriptor_, BlobProtoVector::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PermuteParameter_descriptor_, PermuteParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NormalizeBBoxParameter_descriptor_, NormalizeBBoxParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PriorBoxParameter_descriptor_, PriorBoxParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DetectionOutputParameter_descriptor_, DetectionOutputParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Datum_descriptor_, Datum::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FillerParameter_descriptor_, FillerParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NetParameter_descriptor_, NetParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SolverParameter_descriptor_, SolverParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SolverState_descriptor_, SolverState::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NetState_descriptor_, NetState::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NetStateRule_descriptor_, NetStateRule::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ParamSpec_descriptor_, ParamSpec::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LayerParameter_descriptor_, LayerParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TransformationParameter_descriptor_, TransformationParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LossParameter_descriptor_, LossParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccuracyParameter_descriptor_, AccuracyParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ArgMaxParameter_descriptor_, ArgMaxParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ConcatParameter_descriptor_, ConcatParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BatchNormParameter_descriptor_, BatchNormParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BiasParameter_descriptor_, BiasParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ContrastiveLossParameter_descriptor_, ContrastiveLossParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ConvolutionParameter_descriptor_, ConvolutionParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CropParameter_descriptor_, CropParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DataParameter_descriptor_, DataParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NonMaximumSuppressionParameter_descriptor_, NonMaximumSuppressionParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SaveOutputParameter_descriptor_, SaveOutputParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DropoutParameter_descriptor_, DropoutParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DummyDataParameter_descriptor_, DummyDataParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + EltwiseParameter_descriptor_, EltwiseParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ELUParameter_descriptor_, ELUParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + EmbedParameter_descriptor_, EmbedParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ExpParameter_descriptor_, ExpParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FlattenParameter_descriptor_, FlattenParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + HDF5DataParameter_descriptor_, HDF5DataParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + HDF5OutputParameter_descriptor_, HDF5OutputParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + HingeLossParameter_descriptor_, HingeLossParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ImageDataParameter_descriptor_, ImageDataParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InfogainLossParameter_descriptor_, InfogainLossParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InnerProductParameter_descriptor_, InnerProductParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InputParameter_descriptor_, InputParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LogParameter_descriptor_, LogParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LRNParameter_descriptor_, LRNParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + MemoryDataParameter_descriptor_, MemoryDataParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + MVNParameter_descriptor_, MVNParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ParameterParameter_descriptor_, ParameterParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PoolingParameter_descriptor_, PoolingParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PowerParameter_descriptor_, PowerParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PythonParameter_descriptor_, PythonParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RecurrentParameter_descriptor_, RecurrentParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ReductionParameter_descriptor_, ReductionParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ReLUParameter_descriptor_, ReLUParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ReshapeParameter_descriptor_, ReshapeParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ScaleParameter_descriptor_, ScaleParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SigmoidParameter_descriptor_, SigmoidParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SliceParameter_descriptor_, SliceParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SoftmaxParameter_descriptor_, SoftmaxParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TanHParameter_descriptor_, TanHParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TileParameter_descriptor_, TileParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ThresholdParameter_descriptor_, ThresholdParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + WindowDataParameter_descriptor_, WindowDataParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SPPParameter_descriptor_, SPPParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + V1LayerParameter_descriptor_, V1LayerParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + V0LayerParameter_descriptor_, V0LayerParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PReLUParameter_descriptor_, PReLUParameter::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NormalizedBBox_descriptor_, NormalizedBBox::internal_default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_caffe_2eproto() { + BlobShape_default_instance_.Shutdown(); + delete BlobShape_reflection_; + BlobProto_default_instance_.Shutdown(); + delete BlobProto_reflection_; + BlobProtoVector_default_instance_.Shutdown(); + delete BlobProtoVector_reflection_; + PermuteParameter_default_instance_.Shutdown(); + delete PermuteParameter_reflection_; + NormalizeBBoxParameter_default_instance_.Shutdown(); + delete NormalizeBBoxParameter_reflection_; + PriorBoxParameter_default_instance_.Shutdown(); + delete PriorBoxParameter_reflection_; + DetectionOutputParameter_default_instance_.Shutdown(); + delete DetectionOutputParameter_reflection_; + Datum_default_instance_.Shutdown(); + delete Datum_reflection_; + FillerParameter_default_instance_.Shutdown(); + delete FillerParameter_reflection_; + delete FillerParameter::_default_type_; + NetParameter_default_instance_.Shutdown(); + delete NetParameter_reflection_; + SolverParameter_default_instance_.Shutdown(); + delete SolverParameter_reflection_; + delete SolverParameter::_default_regularization_type_; + delete SolverParameter::_default_type_; + SolverState_default_instance_.Shutdown(); + delete SolverState_reflection_; + NetState_default_instance_.Shutdown(); + delete NetState_reflection_; + NetStateRule_default_instance_.Shutdown(); + delete NetStateRule_reflection_; + ParamSpec_default_instance_.Shutdown(); + delete ParamSpec_reflection_; + LayerParameter_default_instance_.Shutdown(); + delete LayerParameter_reflection_; + TransformationParameter_default_instance_.Shutdown(); + delete TransformationParameter_reflection_; + LossParameter_default_instance_.Shutdown(); + delete LossParameter_reflection_; + AccuracyParameter_default_instance_.Shutdown(); + delete AccuracyParameter_reflection_; + ArgMaxParameter_default_instance_.Shutdown(); + delete ArgMaxParameter_reflection_; + ConcatParameter_default_instance_.Shutdown(); + delete ConcatParameter_reflection_; + BatchNormParameter_default_instance_.Shutdown(); + delete BatchNormParameter_reflection_; + BiasParameter_default_instance_.Shutdown(); + delete BiasParameter_reflection_; + ContrastiveLossParameter_default_instance_.Shutdown(); + delete ContrastiveLossParameter_reflection_; + ConvolutionParameter_default_instance_.Shutdown(); + delete ConvolutionParameter_reflection_; + CropParameter_default_instance_.Shutdown(); + delete CropParameter_reflection_; + DataParameter_default_instance_.Shutdown(); + delete DataParameter_reflection_; + NonMaximumSuppressionParameter_default_instance_.Shutdown(); + delete NonMaximumSuppressionParameter_reflection_; + SaveOutputParameter_default_instance_.Shutdown(); + delete SaveOutputParameter_reflection_; + DropoutParameter_default_instance_.Shutdown(); + delete DropoutParameter_reflection_; + DummyDataParameter_default_instance_.Shutdown(); + delete DummyDataParameter_reflection_; + EltwiseParameter_default_instance_.Shutdown(); + delete EltwiseParameter_reflection_; + ELUParameter_default_instance_.Shutdown(); + delete ELUParameter_reflection_; + EmbedParameter_default_instance_.Shutdown(); + delete EmbedParameter_reflection_; + ExpParameter_default_instance_.Shutdown(); + delete ExpParameter_reflection_; + FlattenParameter_default_instance_.Shutdown(); + delete FlattenParameter_reflection_; + HDF5DataParameter_default_instance_.Shutdown(); + delete HDF5DataParameter_reflection_; + HDF5OutputParameter_default_instance_.Shutdown(); + delete HDF5OutputParameter_reflection_; + HingeLossParameter_default_instance_.Shutdown(); + delete HingeLossParameter_reflection_; + ImageDataParameter_default_instance_.Shutdown(); + delete ImageDataParameter_reflection_; + InfogainLossParameter_default_instance_.Shutdown(); + delete InfogainLossParameter_reflection_; + InnerProductParameter_default_instance_.Shutdown(); + delete InnerProductParameter_reflection_; + InputParameter_default_instance_.Shutdown(); + delete InputParameter_reflection_; + LogParameter_default_instance_.Shutdown(); + delete LogParameter_reflection_; + LRNParameter_default_instance_.Shutdown(); + delete LRNParameter_reflection_; + MemoryDataParameter_default_instance_.Shutdown(); + delete MemoryDataParameter_reflection_; + MVNParameter_default_instance_.Shutdown(); + delete MVNParameter_reflection_; + ParameterParameter_default_instance_.Shutdown(); + delete ParameterParameter_reflection_; + PoolingParameter_default_instance_.Shutdown(); + delete PoolingParameter_reflection_; + PowerParameter_default_instance_.Shutdown(); + delete PowerParameter_reflection_; + PythonParameter_default_instance_.Shutdown(); + delete PythonParameter_reflection_; + RecurrentParameter_default_instance_.Shutdown(); + delete RecurrentParameter_reflection_; + ReductionParameter_default_instance_.Shutdown(); + delete ReductionParameter_reflection_; + ReLUParameter_default_instance_.Shutdown(); + delete ReLUParameter_reflection_; + ReshapeParameter_default_instance_.Shutdown(); + delete ReshapeParameter_reflection_; + ScaleParameter_default_instance_.Shutdown(); + delete ScaleParameter_reflection_; + SigmoidParameter_default_instance_.Shutdown(); + delete SigmoidParameter_reflection_; + SliceParameter_default_instance_.Shutdown(); + delete SliceParameter_reflection_; + SoftmaxParameter_default_instance_.Shutdown(); + delete SoftmaxParameter_reflection_; + TanHParameter_default_instance_.Shutdown(); + delete TanHParameter_reflection_; + TileParameter_default_instance_.Shutdown(); + delete TileParameter_reflection_; + ThresholdParameter_default_instance_.Shutdown(); + delete ThresholdParameter_reflection_; + WindowDataParameter_default_instance_.Shutdown(); + delete WindowDataParameter_reflection_; + delete WindowDataParameter::_default_crop_mode_; + SPPParameter_default_instance_.Shutdown(); + delete SPPParameter_reflection_; + V1LayerParameter_default_instance_.Shutdown(); + delete V1LayerParameter_reflection_; + V0LayerParameter_default_instance_.Shutdown(); + delete V0LayerParameter_reflection_; + delete V0LayerParameter::_default_det_crop_mode_; + PReLUParameter_default_instance_.Shutdown(); + delete PReLUParameter_reflection_; + NormalizedBBox_default_instance_.Shutdown(); + delete NormalizedBBox_reflection_; +} + +void protobuf_InitDefaults_caffe_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + BlobShape_default_instance_.DefaultConstruct(); + BlobProto_default_instance_.DefaultConstruct(); + BlobProtoVector_default_instance_.DefaultConstruct(); + PermuteParameter_default_instance_.DefaultConstruct(); + NormalizeBBoxParameter_default_instance_.DefaultConstruct(); + PriorBoxParameter_default_instance_.DefaultConstruct(); + DetectionOutputParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + Datum_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + FillerParameter::_default_type_ = + new ::std::string("constant", 8); + FillerParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + NetParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + SolverParameter::_default_regularization_type_ = + new ::std::string("L2", 2); + SolverParameter::_default_type_ = + new ::std::string("SGD", 3); + SolverParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + SolverState_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + NetState_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + NetStateRule_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + ParamSpec_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + LayerParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + TransformationParameter_default_instance_.DefaultConstruct(); + LossParameter_default_instance_.DefaultConstruct(); + AccuracyParameter_default_instance_.DefaultConstruct(); + ArgMaxParameter_default_instance_.DefaultConstruct(); + ConcatParameter_default_instance_.DefaultConstruct(); + BatchNormParameter_default_instance_.DefaultConstruct(); + BiasParameter_default_instance_.DefaultConstruct(); + ContrastiveLossParameter_default_instance_.DefaultConstruct(); + ConvolutionParameter_default_instance_.DefaultConstruct(); + CropParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + DataParameter_default_instance_.DefaultConstruct(); + NonMaximumSuppressionParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + SaveOutputParameter_default_instance_.DefaultConstruct(); + DropoutParameter_default_instance_.DefaultConstruct(); + DummyDataParameter_default_instance_.DefaultConstruct(); + EltwiseParameter_default_instance_.DefaultConstruct(); + ELUParameter_default_instance_.DefaultConstruct(); + EmbedParameter_default_instance_.DefaultConstruct(); + ExpParameter_default_instance_.DefaultConstruct(); + FlattenParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + HDF5DataParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + HDF5OutputParameter_default_instance_.DefaultConstruct(); + HingeLossParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + ImageDataParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + InfogainLossParameter_default_instance_.DefaultConstruct(); + InnerProductParameter_default_instance_.DefaultConstruct(); + InputParameter_default_instance_.DefaultConstruct(); + LogParameter_default_instance_.DefaultConstruct(); + LRNParameter_default_instance_.DefaultConstruct(); + MemoryDataParameter_default_instance_.DefaultConstruct(); + MVNParameter_default_instance_.DefaultConstruct(); + ParameterParameter_default_instance_.DefaultConstruct(); + PoolingParameter_default_instance_.DefaultConstruct(); + PowerParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + PythonParameter_default_instance_.DefaultConstruct(); + RecurrentParameter_default_instance_.DefaultConstruct(); + ReductionParameter_default_instance_.DefaultConstruct(); + ReLUParameter_default_instance_.DefaultConstruct(); + ReshapeParameter_default_instance_.DefaultConstruct(); + ScaleParameter_default_instance_.DefaultConstruct(); + SigmoidParameter_default_instance_.DefaultConstruct(); + SliceParameter_default_instance_.DefaultConstruct(); + SoftmaxParameter_default_instance_.DefaultConstruct(); + TanHParameter_default_instance_.DefaultConstruct(); + TileParameter_default_instance_.DefaultConstruct(); + ThresholdParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + WindowDataParameter::_default_crop_mode_ = + new ::std::string("warp", 4); + WindowDataParameter_default_instance_.DefaultConstruct(); + SPPParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + V1LayerParameter_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + V0LayerParameter::_default_det_crop_mode_ = + new ::std::string("warp", 4); + V0LayerParameter_default_instance_.DefaultConstruct(); + PReLUParameter_default_instance_.DefaultConstruct(); + NormalizedBBox_default_instance_.DefaultConstruct(); + BlobShape_default_instance_.get_mutable()->InitAsDefaultInstance(); + BlobProto_default_instance_.get_mutable()->InitAsDefaultInstance(); + BlobProtoVector_default_instance_.get_mutable()->InitAsDefaultInstance(); + PermuteParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + NormalizeBBoxParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + PriorBoxParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + DetectionOutputParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + Datum_default_instance_.get_mutable()->InitAsDefaultInstance(); + FillerParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + NetParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + SolverParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + SolverState_default_instance_.get_mutable()->InitAsDefaultInstance(); + NetState_default_instance_.get_mutable()->InitAsDefaultInstance(); + NetStateRule_default_instance_.get_mutable()->InitAsDefaultInstance(); + ParamSpec_default_instance_.get_mutable()->InitAsDefaultInstance(); + LayerParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + TransformationParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + LossParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + AccuracyParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ArgMaxParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ConcatParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + BatchNormParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + BiasParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ContrastiveLossParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ConvolutionParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + CropParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + DataParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + NonMaximumSuppressionParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + SaveOutputParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + DropoutParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + DummyDataParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + EltwiseParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ELUParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + EmbedParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ExpParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + FlattenParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + HDF5DataParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + HDF5OutputParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + HingeLossParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ImageDataParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + InfogainLossParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + InnerProductParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + InputParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + LogParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + LRNParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + MemoryDataParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + MVNParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ParameterParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + PoolingParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + PowerParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + PythonParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + RecurrentParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ReductionParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ReLUParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ReshapeParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ScaleParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + SigmoidParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + SliceParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + SoftmaxParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + TanHParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + TileParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + ThresholdParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + WindowDataParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + SPPParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + V1LayerParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + V0LayerParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + PReLUParameter_default_instance_.get_mutable()->InitAsDefaultInstance(); + NormalizedBBox_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_caffe_2eproto_once_); +void protobuf_InitDefaults_caffe_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_caffe_2eproto_once_, + &protobuf_InitDefaults_caffe_2eproto_impl); +} +void protobuf_AddDesc_caffe_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_caffe_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\013caffe.proto\022\005caffe\"\034\n\tBlobShape\022\017\n\003dim" + "\030\001 \003(\003B\002\020\001\"\314\001\n\tBlobProto\022\037\n\005shape\030\007 \001(\0132" + "\020.caffe.BlobShape\022\020\n\004data\030\005 \003(\002B\002\020\001\022\020\n\004d" + "iff\030\006 \003(\002B\002\020\001\022\027\n\013double_data\030\010 \003(\001B\002\020\001\022\027" + "\n\013double_diff\030\t \003(\001B\002\020\001\022\016\n\003num\030\001 \001(\005:\0010\022" + "\023\n\010channels\030\002 \001(\005:\0010\022\021\n\006height\030\003 \001(\005:\0010\022" + "\020\n\005width\030\004 \001(\005:\0010\"2\n\017BlobProtoVector\022\037\n\005" + "blobs\030\001 \003(\0132\020.caffe.BlobProto\"!\n\020Permute" + "Parameter\022\r\n\005order\030\001 \003(\r\"\226\001\n\026NormalizeBB" + "oxParameter\022\034\n\016across_spatial\030\001 \001(\010:\004tru" + "e\022,\n\014scale_filler\030\002 \001(\0132\026.caffe.FillerPa" + "rameter\022\034\n\016channel_shared\030\003 \001(\010:\004true\022\022\n" + "\003eps\030\004 \001(\002:\0051e-10\"\243\002\n\021PriorBoxParameter\022" + "\020\n\010min_size\030\001 \001(\002\022\020\n\010max_size\030\002 \001(\002\022\024\n\014a" + "spect_ratio\030\003 \003(\002\022\022\n\004flip\030\004 \001(\010:\004true\022\022\n" + "\004clip\030\005 \001(\010:\004true\022\020\n\010variance\030\006 \003(\002\022\020\n\010i" + "mg_size\030\007 \001(\r\022\r\n\005img_h\030\010 \001(\r\022\r\n\005img_w\030\t " + "\001(\r\022\014\n\004step\030\n \001(\002\022\016\n\006step_h\030\013 \001(\002\022\016\n\006ste" + "p_w\030\014 \001(\002\022\023\n\006offset\030\r \001(\002:\0030.5\"\'\n\010CodeTy" + "pe\022\n\n\006CORNER\020\001\022\017\n\013CENTER_SIZE\020\002\"\375\002\n\030Dete" + "ctionOutputParameter\022\023\n\013num_classes\030\001 \001(" + "\r\022\034\n\016share_location\030\002 \001(\010:\004true\022\036\n\023backg" + "round_label_id\030\003 \001(\005:\0010\0228\n\tnms_param\030\004 \001" + "(\0132%.caffe.NonMaximumSuppressionParamete" + "r\0225\n\021save_output_param\030\005 \001(\0132\032.caffe.Sav" + "eOutputParameter\022<\n\tcode_type\030\006 \001(\0162!.ca" + "ffe.PriorBoxParameter.CodeType:\006CORNER\022)" + "\n\032variance_encoded_in_target\030\010 \001(\010:\005fals" + "e\022\026\n\nkeep_top_k\030\007 \001(\005:\002-1\022\034\n\024confidence_" + "threshold\030\t \001(\002\"\201\001\n\005Datum\022\020\n\010channels\030\001 " + "\001(\005\022\016\n\006height\030\002 \001(\005\022\r\n\005width\030\003 \001(\005\022\014\n\004da" + "ta\030\004 \001(\014\022\r\n\005label\030\005 \001(\005\022\022\n\nfloat_data\030\006 " + "\003(\002\022\026\n\007encoded\030\007 \001(\010:\005false\"\212\002\n\017FillerPa" + "rameter\022\026\n\004type\030\001 \001(\t:\010constant\022\020\n\005value" + "\030\002 \001(\002:\0010\022\016\n\003min\030\003 \001(\002:\0010\022\016\n\003max\030\004 \001(\002:\001" + "1\022\017\n\004mean\030\005 \001(\002:\0010\022\016\n\003std\030\006 \001(\002:\0011\022\022\n\006sp" + "arse\030\007 \001(\005:\002-1\022B\n\rvariance_norm\030\010 \001(\0162#." + "caffe.FillerParameter.VarianceNorm:\006FAN_" + "IN\"4\n\014VarianceNorm\022\n\n\006FAN_IN\020\000\022\013\n\007FAN_OU" + "T\020\001\022\013\n\007AVERAGE\020\002\"\216\002\n\014NetParameter\022\014\n\004nam" + "e\030\001 \001(\t\022\r\n\005input\030\003 \003(\t\022%\n\013input_shape\030\010 " + "\003(\0132\020.caffe.BlobShape\022\021\n\tinput_dim\030\004 \003(\005" + "\022\035\n\016force_backward\030\005 \001(\010:\005false\022\036\n\005state" + "\030\006 \001(\0132\017.caffe.NetState\022\031\n\ndebug_info\030\007 " + "\001(\010:\005false\022$\n\005layer\030d \003(\0132\025.caffe.LayerP" + "arameter\022\'\n\006layers\030\002 \003(\0132\027.caffe.V1Layer" + "Parameter\"\242\n\n\017SolverParameter\022\013\n\003net\030\030 \001" + "(\t\022&\n\tnet_param\030\031 \001(\0132\023.caffe.NetParamet" + "er\022\021\n\ttrain_net\030\001 \001(\t\022\020\n\010test_net\030\002 \003(\t\022" + ",\n\017train_net_param\030\025 \001(\0132\023.caffe.NetPara" + "meter\022+\n\016test_net_param\030\026 \003(\0132\023.caffe.Ne" + "tParameter\022$\n\013train_state\030\032 \001(\0132\017.caffe." + "NetState\022#\n\ntest_state\030\033 \003(\0132\017.caffe.Net" + "State\022\021\n\ttest_iter\030\003 \003(\005\022\030\n\rtest_interva" + "l\030\004 \001(\005:\0010\022 \n\021test_compute_loss\030\023 \001(\010:\005f" + "alse\022!\n\023test_initialization\030 \001(\010:\004true\022" + "\017\n\007base_lr\030\005 \001(\002\022\017\n\007display\030\006 \001(\005\022\027\n\014ave" + "rage_loss\030! \001(\005:\0011\022\020\n\010max_iter\030\007 \001(\005\022\024\n\t" + "iter_size\030$ \001(\005:\0011\022\021\n\tlr_policy\030\010 \001(\t\022\r\n" + "\005gamma\030\t \001(\002\022\r\n\005power\030\n \001(\002\022\020\n\010momentum\030" + "\013 \001(\002\022\024\n\014weight_decay\030\014 \001(\002\022\037\n\023regulariz" + "ation_type\030\035 \001(\t:\002L2\022\020\n\010stepsize\030\r \001(\005\022\021" + "\n\tstepvalue\030\" \003(\005\022\032\n\016clip_gradients\030# \001(" + "\002:\002-1\022\023\n\010snapshot\030\016 \001(\005:\0010\022\027\n\017snapshot_p" + "refix\030\017 \001(\t\022\034\n\rsnapshot_diff\030\020 \001(\010:\005fals" + "e\022K\n\017snapshot_format\030% \001(\0162%.caffe.Solve" + "rParameter.SnapshotFormat:\013BINARYPROTO\022;" + "\n\013solver_mode\030\021 \001(\0162!.caffe.SolverParame" + "ter.SolverMode:\003GPU\022\024\n\tdevice_id\030\022 \001(\005:\001" + "0\022\027\n\013random_seed\030\024 \001(\003:\002-1\022\021\n\004type\030( \001(\t" + ":\003SGD\022\024\n\005delta\030\037 \001(\002:\0051e-08\022\030\n\tmomentum2" + "\030\' \001(\002:\0050.999\022\027\n\trms_decay\030& \001(\002:\0040.99\022\031" + "\n\ndebug_info\030\027 \001(\010:\005false\022\"\n\024snapshot_af" + "ter_train\030\034 \001(\010:\004true\022;\n\013solver_type\030\036 \001" + "(\0162!.caffe.SolverParameter.SolverType:\003S" + "GD\"+\n\016SnapshotFormat\022\010\n\004HDF5\020\000\022\017\n\013BINARY" + "PROTO\020\001\"\036\n\nSolverMode\022\007\n\003CPU\020\000\022\007\n\003GPU\020\001\"" + "U\n\nSolverType\022\007\n\003SGD\020\000\022\014\n\010NESTEROV\020\001\022\013\n\007" + "ADAGRAD\020\002\022\013\n\007RMSPROP\020\003\022\014\n\010ADADELTA\020\004\022\010\n\004" + "ADAM\020\005\"l\n\013SolverState\022\014\n\004iter\030\001 \001(\005\022\023\n\013l" + "earned_net\030\002 \001(\t\022!\n\007history\030\003 \003(\0132\020.caff" + "e.BlobProto\022\027\n\014current_step\030\004 \001(\005:\0010\"N\n\010" + "NetState\022!\n\005phase\030\001 \001(\0162\014.caffe.Phase:\004T" + "EST\022\020\n\005level\030\002 \001(\005:\0010\022\r\n\005stage\030\003 \003(\t\"s\n\014" + "NetStateRule\022\033\n\005phase\030\001 \001(\0162\014.caffe.Phas" + "e\022\021\n\tmin_level\030\002 \001(\005\022\021\n\tmax_level\030\003 \001(\005\022" + "\r\n\005stage\030\004 \003(\t\022\021\n\tnot_stage\030\005 \003(\t\"\243\001\n\tPa" + "ramSpec\022\014\n\004name\030\001 \001(\t\0221\n\nshare_mode\030\002 \001(" + "\0162\035.caffe.ParamSpec.DimCheckMode\022\022\n\007lr_m" + "ult\030\003 \001(\002:\0011\022\025\n\ndecay_mult\030\004 \001(\002:\0011\"*\n\014D" + "imCheckMode\022\n\n\006STRICT\020\000\022\016\n\nPERMISSIVE\020\001\"" + "\335\025\n\016LayerParameter\022\014\n\004name\030\001 \001(\t\022\014\n\004type" + "\030\002 \001(\t\022\016\n\006bottom\030\003 \003(\t\022\013\n\003top\030\004 \003(\t\022\033\n\005p" + "hase\030\n \001(\0162\014.caffe.Phase\022\023\n\013loss_weight\030" + "\005 \003(\002\022\037\n\005param\030\006 \003(\0132\020.caffe.ParamSpec\022\037" + "\n\005blobs\030\007 \003(\0132\020.caffe.BlobProto\022\026\n\016propa" + "gate_down\030\013 \003(\010\022$\n\007include\030\010 \003(\0132\023.caffe" + ".NetStateRule\022$\n\007exclude\030\t \003(\0132\023.caffe.N" + "etStateRule\0227\n\017transform_param\030d \001(\0132\036.c" + "affe.TransformationParameter\022(\n\nloss_par" + "am\030e \001(\0132\024.caffe.LossParameter\0220\n\016accura" + "cy_param\030f \001(\0132\030.caffe.AccuracyParameter" + "\022,\n\014argmax_param\030g \001(\0132\026.caffe.ArgMaxPar" + "ameter\0224\n\020batch_norm_param\030\213\001 \001(\0132\031.caff" + "e.BatchNormParameter\022)\n\nbias_param\030\215\001 \001(" + "\0132\024.caffe.BiasParameter\022,\n\014concat_param\030" + "h \001(\0132\026.caffe.ConcatParameter\022\?\n\026contras" + "tive_loss_param\030i \001(\0132\037.caffe.Contrastiv" + "eLossParameter\0226\n\021convolution_param\030j \001(" + "\0132\033.caffe.ConvolutionParameter\022)\n\ncrop_p" + "aram\030\220\001 \001(\0132\024.caffe.CropParameter\022(\n\ndat" + "a_param\030k \001(\0132\024.caffe.DataParameter\022@\n\026d" + "etection_output_param\030\223\001 \001(\0132\037.caffe.Det" + "ectionOutputParameter\022.\n\rdropout_param\030l" + " \001(\0132\027.caffe.DropoutParameter\0223\n\020dummy_d" + "ata_param\030m \001(\0132\031.caffe.DummyDataParamet" + "er\022.\n\reltwise_param\030n \001(\0132\027.caffe.Eltwis" + "eParameter\022\'\n\telu_param\030\214\001 \001(\0132\023.caffe.E" + "LUParameter\022+\n\013embed_param\030\211\001 \001(\0132\025.caff" + "e.EmbedParameter\022&\n\texp_param\030o \001(\0132\023.ca" + "ffe.ExpParameter\022/\n\rflatten_param\030\207\001 \001(\013" + "2\027.caffe.FlattenParameter\0221\n\017hdf5_data_p" + "aram\030p \001(\0132\030.caffe.HDF5DataParameter\0225\n\021" + "hdf5_output_param\030q \001(\0132\032.caffe.HDF5Outp" + "utParameter\0223\n\020hinge_loss_param\030r \001(\0132\031." + "caffe.HingeLossParameter\0223\n\020image_data_p" + "aram\030s \001(\0132\031.caffe.ImageDataParameter\0229\n" + "\023infogain_loss_param\030t \001(\0132\034.caffe.Infog" + "ainLossParameter\0229\n\023inner_product_param\030" + "u \001(\0132\034.caffe.InnerProductParameter\022+\n\013i" + "nput_param\030\217\001 \001(\0132\025.caffe.InputParameter" + "\022\'\n\tlog_param\030\206\001 \001(\0132\023.caffe.LogParamete" + "r\022&\n\tlrn_param\030v \001(\0132\023.caffe.LRNParamete" + "r\0225\n\021memory_data_param\030w \001(\0132\032.caffe.Mem" + "oryDataParameter\022&\n\tmvn_param\030x \001(\0132\023.ca" + "ffe.MVNParameter\0222\n\nnorm_param\030\225\001 \001(\0132\035." + "caffe.NormalizeBBoxParameter\022/\n\rpermute_" + "param\030\224\001 \001(\0132\027.caffe.PermuteParameter\0223\n" + "\017parameter_param\030\221\001 \001(\0132\031.caffe.Paramete" + "rParameter\022.\n\rpooling_param\030y \001(\0132\027.caff" + "e.PoolingParameter\022*\n\013power_param\030z \001(\0132" + "\025.caffe.PowerParameter\022+\n\013prelu_param\030\203\001" + " \001(\0132\025.caffe.PReLUParameter\0222\n\017prior_box" + "_param\030\226\001 \001(\0132\030.caffe.PriorBoxParameter\022" + "-\n\014python_param\030\202\001 \001(\0132\026.caffe.PythonPar" + "ameter\0223\n\017recurrent_param\030\222\001 \001(\0132\031.caffe" + ".RecurrentParameter\0223\n\017reduction_param\030\210" + "\001 \001(\0132\031.caffe.ReductionParameter\022(\n\nrelu" + "_param\030{ \001(\0132\024.caffe.ReLUParameter\022/\n\rre" + "shape_param\030\205\001 \001(\0132\027.caffe.ReshapeParame" + "ter\022+\n\013scale_param\030\216\001 \001(\0132\025.caffe.ScaleP" + "arameter\022.\n\rsigmoid_param\030| \001(\0132\027.caffe." + "SigmoidParameter\022.\n\rsoftmax_param\030} \001(\0132" + "\027.caffe.SoftmaxParameter\022\'\n\tspp_param\030\204\001" + " \001(\0132\023.caffe.SPPParameter\022*\n\013slice_param" + "\030~ \001(\0132\025.caffe.SliceParameter\022(\n\ntanh_pa" + "ram\030\177 \001(\0132\024.caffe.TanHParameter\0223\n\017thres" + "hold_param\030\200\001 \001(\0132\031.caffe.ThresholdParam" + "eter\022)\n\ntile_param\030\212\001 \001(\0132\024.caffe.TilePa" + "rameter\0226\n\021window_data_param\030\201\001 \001(\0132\032.ca" + "ffe.WindowDataParameter\"\266\001\n\027Transformati" + "onParameter\022\020\n\005scale\030\001 \001(\002:\0011\022\025\n\006mirror\030" + "\002 \001(\010:\005false\022\024\n\tcrop_size\030\003 \001(\r:\0010\022\021\n\tme" + "an_file\030\004 \001(\t\022\022\n\nmean_value\030\005 \003(\002\022\032\n\013for" + "ce_color\030\006 \001(\010:\005false\022\031\n\nforce_gray\030\007 \001(" + "\010:\005false\"\302\001\n\rLossParameter\022\024\n\014ignore_lab" + "el\030\001 \001(\005\022D\n\rnormalization\030\003 \001(\0162&.caffe." + "LossParameter.NormalizationMode:\005VALID\022\021" + "\n\tnormalize\030\002 \001(\010\"B\n\021NormalizationMode\022\010" + "\n\004FULL\020\000\022\t\n\005VALID\020\001\022\016\n\nBATCH_SIZE\020\002\022\010\n\004N" + "ONE\020\003\"L\n\021AccuracyParameter\022\020\n\005top_k\030\001 \001(" + "\r:\0011\022\017\n\004axis\030\002 \001(\005:\0011\022\024\n\014ignore_label\030\003 " + "\001(\005\"M\n\017ArgMaxParameter\022\032\n\013out_max_val\030\001 " + "\001(\010:\005false\022\020\n\005top_k\030\002 \001(\r:\0011\022\014\n\004axis\030\003 \001" + "(\005\"9\n\017ConcatParameter\022\017\n\004axis\030\002 \001(\005:\0011\022\025" + "\n\nconcat_dim\030\001 \001(\r:\0011\"j\n\022BatchNormParame" + "ter\022\030\n\020use_global_stats\030\001 \001(\010\022&\n\027moving_" + "average_fraction\030\002 \001(\002:\0050.999\022\022\n\003eps\030\003 \001" + "(\002:\0051e-05\"]\n\rBiasParameter\022\017\n\004axis\030\001 \001(\005" + ":\0011\022\023\n\010num_axes\030\002 \001(\005:\0011\022&\n\006filler\030\003 \001(\013" + "2\026.caffe.FillerParameter\"L\n\030ContrastiveL" + "ossParameter\022\021\n\006margin\030\001 \001(\002:\0011\022\035\n\016legac" + "y_version\030\002 \001(\010:\005false\"\374\003\n\024ConvolutionPa" + "rameter\022\022\n\nnum_output\030\001 \001(\r\022\027\n\tbias_term" + "\030\002 \001(\010:\004true\022\013\n\003pad\030\003 \003(\r\022\023\n\013kernel_size" + "\030\004 \003(\r\022\016\n\006stride\030\006 \003(\r\022\020\n\010dilation\030\022 \003(\r" + "\022\020\n\005pad_h\030\t \001(\r:\0010\022\020\n\005pad_w\030\n \001(\r:\0010\022\020\n\010" + "kernel_h\030\013 \001(\r\022\020\n\010kernel_w\030\014 \001(\r\022\020\n\010stri" + "de_h\030\r \001(\r\022\020\n\010stride_w\030\016 \001(\r\022\020\n\005group\030\005 " + "\001(\r:\0011\022-\n\rweight_filler\030\007 \001(\0132\026.caffe.Fi" + "llerParameter\022+\n\013bias_filler\030\010 \001(\0132\026.caf" + "fe.FillerParameter\022;\n\006engine\030\017 \001(\0162\".caf" + "fe.ConvolutionParameter.Engine:\007DEFAULT\022" + "\017\n\004axis\030\020 \001(\005:\0011\022\036\n\017force_nd_im2col\030\021 \001(" + "\010:\005false\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE" + "\020\001\022\t\n\005CUDNN\020\002\"0\n\rCropParameter\022\017\n\004axis\030\001" + " \001(\005:\0012\022\016\n\006offset\030\002 \003(\r\"\244\002\n\rDataParamete" + "r\022\016\n\006source\030\001 \001(\t\022\022\n\nbatch_size\030\004 \001(\r\022\024\n" + "\trand_skip\030\007 \001(\r:\0010\0221\n\007backend\030\010 \001(\0162\027.c" + "affe.DataParameter.DB:\007LEVELDB\022\020\n\005scale\030" + "\002 \001(\002:\0011\022\021\n\tmean_file\030\003 \001(\t\022\024\n\tcrop_size" + "\030\005 \001(\r:\0010\022\025\n\006mirror\030\006 \001(\010:\005false\022\"\n\023forc" + "e_encoded_color\030\t \001(\010:\005false\022\023\n\010prefetch" + "\030\n \001(\r:\0014\"\033\n\002DB\022\013\n\007LEVELDB\020\000\022\010\n\004LMDB\020\001\"[" + "\n\036NonMaximumSuppressionParameter\022\032\n\rnms_" + "threshold\030\001 \001(\002:\0030.3\022\r\n\005top_k\030\002 \001(\005\022\016\n\003e" + "ta\030\003 \001(\002:\0011\"\252\001\n\023SaveOutputParameter\022\030\n\020o" + "utput_directory\030\001 \001(\t\022\032\n\022output_name_pre" + "fix\030\002 \001(\t\022\025\n\routput_format\030\003 \001(\t\022\026\n\016labe" + "l_map_file\030\004 \001(\t\022\026\n\016name_size_file\030\005 \001(\t" + "\022\026\n\016num_test_image\030\006 \001(\r\".\n\020DropoutParam" + "eter\022\032\n\rdropout_ratio\030\001 \001(\002:\0030.5\"\240\001\n\022Dum" + "myDataParameter\022+\n\013data_filler\030\001 \003(\0132\026.c" + "affe.FillerParameter\022\037\n\005shape\030\006 \003(\0132\020.ca" + "ffe.BlobShape\022\013\n\003num\030\002 \003(\r\022\020\n\010channels\030\003" + " \003(\r\022\016\n\006height\030\004 \003(\r\022\r\n\005width\030\005 \003(\r\"\245\001\n\020" + "EltwiseParameter\0229\n\toperation\030\001 \001(\0162!.ca" + "ffe.EltwiseParameter.EltwiseOp:\003SUM\022\r\n\005c" + "oeff\030\002 \003(\002\022\036\n\020stable_prod_grad\030\003 \001(\010:\004tr" + "ue\"\'\n\tEltwiseOp\022\010\n\004PROD\020\000\022\007\n\003SUM\020\001\022\007\n\003MA" + "X\020\002\" \n\014ELUParameter\022\020\n\005alpha\030\001 \001(\002:\0011\"\254\001" + "\n\016EmbedParameter\022\022\n\nnum_output\030\001 \001(\r\022\021\n\t" + "input_dim\030\002 \001(\r\022\027\n\tbias_term\030\003 \001(\010:\004true" + "\022-\n\rweight_filler\030\004 \001(\0132\026.caffe.FillerPa" + "rameter\022+\n\013bias_filler\030\005 \001(\0132\026.caffe.Fil" + "lerParameter\"D\n\014ExpParameter\022\020\n\004base\030\001 \001" + "(\002:\002-1\022\020\n\005scale\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:" + "\0010\"9\n\020FlattenParameter\022\017\n\004axis\030\001 \001(\005:\0011\022" + "\024\n\010end_axis\030\002 \001(\005:\002-1\"O\n\021HDF5DataParamet" + "er\022\016\n\006source\030\001 \001(\t\022\022\n\nbatch_size\030\002 \001(\r\022\026" + "\n\007shuffle\030\003 \001(\010:\005false\"(\n\023HDF5OutputPara" + "meter\022\021\n\tfile_name\030\001 \001(\t\"^\n\022HingeLossPar" + "ameter\0220\n\004norm\030\001 \001(\0162\036.caffe.HingeLossPa" + "rameter.Norm:\002L1\"\026\n\004Norm\022\006\n\002L1\020\001\022\006\n\002L2\020\002" + "\"\227\002\n\022ImageDataParameter\022\016\n\006source\030\001 \001(\t\022" + "\025\n\nbatch_size\030\004 \001(\r:\0011\022\024\n\trand_skip\030\007 \001(" + "\r:\0010\022\026\n\007shuffle\030\010 \001(\010:\005false\022\025\n\nnew_heig" + "ht\030\t \001(\r:\0010\022\024\n\tnew_width\030\n \001(\r:\0010\022\026\n\010is_" + "color\030\013 \001(\010:\004true\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\tm" + "ean_file\030\003 \001(\t\022\024\n\tcrop_size\030\005 \001(\r:\0010\022\025\n\006" + "mirror\030\006 \001(\010:\005false\022\025\n\013root_folder\030\014 \001(\t" + ":\000\"\'\n\025InfogainLossParameter\022\016\n\006source\030\001 " + "\001(\t\"\313\001\n\025InnerProductParameter\022\022\n\nnum_out" + "put\030\001 \001(\r\022\027\n\tbias_term\030\002 \001(\010:\004true\022-\n\rwe" + "ight_filler\030\003 \001(\0132\026.caffe.FillerParamete" + "r\022+\n\013bias_filler\030\004 \001(\0132\026.caffe.FillerPar" + "ameter\022\017\n\004axis\030\005 \001(\005:\0011\022\030\n\ttranspose\030\006 \001" + "(\010:\005false\"1\n\016InputParameter\022\037\n\005shape\030\001 \003" + "(\0132\020.caffe.BlobShape\"D\n\014LogParameter\022\020\n\004" + "base\030\001 \001(\002:\002-1\022\020\n\005scale\030\002 \001(\002:\0011\022\020\n\005shif" + "t\030\003 \001(\002:\0010\"\270\002\n\014LRNParameter\022\025\n\nlocal_siz" + "e\030\001 \001(\r:\0015\022\020\n\005alpha\030\002 \001(\002:\0011\022\022\n\004beta\030\003 \001" + "(\002:\0040.75\022D\n\013norm_region\030\004 \001(\0162\036.caffe.LR" + "NParameter.NormRegion:\017ACROSS_CHANNELS\022\014" + "\n\001k\030\005 \001(\002:\0011\0223\n\006engine\030\006 \001(\0162\032.caffe.LRN" + "Parameter.Engine:\007DEFAULT\"5\n\nNormRegion\022" + "\023\n\017ACROSS_CHANNELS\020\000\022\022\n\016WITHIN_CHANNEL\020\001" + "\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CU" + "DNN\020\002\"Z\n\023MemoryDataParameter\022\022\n\nbatch_si" + "ze\030\001 \001(\r\022\020\n\010channels\030\002 \001(\r\022\016\n\006height\030\003 \001" + "(\r\022\r\n\005width\030\004 \001(\r\"d\n\014MVNParameter\022 \n\022nor" + "malize_variance\030\001 \001(\010:\004true\022\036\n\017across_ch" + "annels\030\002 \001(\010:\005false\022\022\n\003eps\030\003 \001(\002:\0051e-09\"" + "5\n\022ParameterParameter\022\037\n\005shape\030\001 \001(\0132\020.c" + "affe.BlobShape\"\242\003\n\020PoolingParameter\0225\n\004p" + "ool\030\001 \001(\0162\".caffe.PoolingParameter.PoolM" + "ethod:\003MAX\022\016\n\003pad\030\004 \001(\r:\0010\022\020\n\005pad_h\030\t \001(" + "\r:\0010\022\020\n\005pad_w\030\n \001(\r:\0010\022\023\n\013kernel_size\030\002 " + "\001(\r\022\020\n\010kernel_h\030\005 \001(\r\022\020\n\010kernel_w\030\006 \001(\r\022" + "\021\n\006stride\030\003 \001(\r:\0011\022\020\n\010stride_h\030\007 \001(\r\022\020\n\010" + "stride_w\030\010 \001(\r\0227\n\006engine\030\013 \001(\0162\036.caffe.P" + "oolingParameter.Engine:\007DEFAULT\022\035\n\016globa" + "l_pooling\030\014 \001(\010:\005false\".\n\nPoolMethod\022\007\n\003" + "MAX\020\000\022\007\n\003AVE\020\001\022\016\n\nSTOCHASTIC\020\002\"+\n\006Engine" + "\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"F\n\016P" + "owerParameter\022\020\n\005power\030\001 \001(\002:\0011\022\020\n\005scale" + "\030\002 \001(\002:\0011\022\020\n\005shift\030\003 \001(\002:\0010\"g\n\017PythonPar" + "ameter\022\016\n\006module\030\001 \001(\t\022\r\n\005layer\030\002 \001(\t\022\023\n" + "\tparam_str\030\003 \001(\t:\000\022 \n\021share_in_parallel\030" + "\004 \001(\010:\005false\"\300\001\n\022RecurrentParameter\022\025\n\nn" + "um_output\030\001 \001(\r:\0010\022-\n\rweight_filler\030\002 \001(" + "\0132\026.caffe.FillerParameter\022+\n\013bias_filler" + "\030\003 \001(\0132\026.caffe.FillerParameter\022\031\n\ndebug_" + "info\030\004 \001(\010:\005false\022\034\n\rexpose_hidden\030\005 \001(\010" + ":\005false\"\255\001\n\022ReductionParameter\022=\n\toperat" + "ion\030\001 \001(\0162%.caffe.ReductionParameter.Red" + "uctionOp:\003SUM\022\017\n\004axis\030\002 \001(\005:\0010\022\020\n\005coeff\030" + "\003 \001(\002:\0011\"5\n\013ReductionOp\022\007\n\003SUM\020\001\022\010\n\004ASUM" + "\020\002\022\t\n\005SUMSQ\020\003\022\010\n\004MEAN\020\004\"\215\001\n\rReLUParamete" + "r\022\031\n\016negative_slope\030\001 \001(\002:\0010\0224\n\006engine\030\002" + " \001(\0162\033.caffe.ReLUParameter.Engine:\007DEFAU" + "LT\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005" + "CUDNN\020\002\"Z\n\020ReshapeParameter\022\037\n\005shape\030\001 \001" + "(\0132\020.caffe.BlobShape\022\017\n\004axis\030\002 \001(\005:\0010\022\024\n" + "\010num_axes\030\003 \001(\005:\002-1\"\245\001\n\016ScaleParameter\022\017" + "\n\004axis\030\001 \001(\005:\0011\022\023\n\010num_axes\030\002 \001(\005:\0011\022&\n\006" + "filler\030\003 \001(\0132\026.caffe.FillerParameter\022\030\n\t" + "bias_term\030\004 \001(\010:\005false\022+\n\013bias_filler\030\005 " + "\001(\0132\026.caffe.FillerParameter\"x\n\020SigmoidPa" + "rameter\0227\n\006engine\030\001 \001(\0162\036.caffe.SigmoidP" + "arameter.Engine:\007DEFAULT\"+\n\006Engine\022\013\n\007DE" + "FAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"L\n\016SlicePa" + "rameter\022\017\n\004axis\030\003 \001(\005:\0011\022\023\n\013slice_point\030" + "\002 \003(\r\022\024\n\tslice_dim\030\001 \001(\r:\0011\"\211\001\n\020SoftmaxP" + "arameter\0227\n\006engine\030\001 \001(\0162\036.caffe.Softmax" + "Parameter.Engine:\007DEFAULT\022\017\n\004axis\030\002 \001(\005:" + "\0011\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005" + "CUDNN\020\002\"r\n\rTanHParameter\0224\n\006engine\030\001 \001(\016" + "2\033.caffe.TanHParameter.Engine:\007DEFAULT\"+" + "\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDN" + "N\020\002\"/\n\rTileParameter\022\017\n\004axis\030\001 \001(\005:\0011\022\r\n" + "\005tiles\030\002 \001(\005\"*\n\022ThresholdParameter\022\024\n\tth" + "reshold\030\001 \001(\002:\0010\"\301\002\n\023WindowDataParameter" + "\022\016\n\006source\030\001 \001(\t\022\020\n\005scale\030\002 \001(\002:\0011\022\021\n\tme" + "an_file\030\003 \001(\t\022\022\n\nbatch_size\030\004 \001(\r\022\024\n\tcro" + "p_size\030\005 \001(\r:\0010\022\025\n\006mirror\030\006 \001(\010:\005false\022\031" + "\n\014fg_threshold\030\007 \001(\002:\0030.5\022\031\n\014bg_threshol" + "d\030\010 \001(\002:\0030.5\022\031\n\013fg_fraction\030\t \001(\002:\0040.25\022" + "\026\n\013context_pad\030\n \001(\r:\0010\022\027\n\tcrop_mode\030\013 \001" + "(\t:\004warp\022\033\n\014cache_images\030\014 \001(\010:\005false\022\025\n" + "\013root_folder\030\r \001(\t:\000\"\353\001\n\014SPPParameter\022\026\n" + "\016pyramid_height\030\001 \001(\r\0221\n\004pool\030\002 \001(\0162\036.ca" + "ffe.SPPParameter.PoolMethod:\003MAX\0223\n\006engi" + "ne\030\006 \001(\0162\032.caffe.SPPParameter.Engine:\007DE" + "FAULT\".\n\nPoolMethod\022\007\n\003MAX\020\000\022\007\n\003AVE\020\001\022\016\n" + "\nSTOCHASTIC\020\002\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005" + "CAFFE\020\001\022\t\n\005CUDNN\020\002\"\340\023\n\020V1LayerParameter\022" + "\016\n\006bottom\030\002 \003(\t\022\013\n\003top\030\003 \003(\t\022\014\n\004name\030\004 \001" + "(\t\022$\n\007include\030 \003(\0132\023.caffe.NetStateRule" + "\022$\n\007exclude\030! \003(\0132\023.caffe.NetStateRule\022/" + "\n\004type\030\005 \001(\0162!.caffe.V1LayerParameter.La" + "yerType\022\037\n\005blobs\030\006 \003(\0132\020.caffe.BlobProto" + "\022\016\n\005param\030\351\007 \003(\t\022>\n\017blob_share_mode\030\352\007 \003" + "(\0162$.caffe.V1LayerParameter.DimCheckMode" + "\022\020\n\010blobs_lr\030\007 \003(\002\022\024\n\014weight_decay\030\010 \003(\002" + "\022\023\n\013loss_weight\030# \003(\002\0220\n\016accuracy_param\030" + "\033 \001(\0132\030.caffe.AccuracyParameter\022,\n\014argma" + "x_param\030\027 \001(\0132\026.caffe.ArgMaxParameter\022,\n" + "\014concat_param\030\t \001(\0132\026.caffe.ConcatParame" + "ter\022\?\n\026contrastive_loss_param\030( \001(\0132\037.ca" + "ffe.ContrastiveLossParameter\0226\n\021convolut" + "ion_param\030\n \001(\0132\033.caffe.ConvolutionParam" + "eter\022(\n\ndata_param\030\013 \001(\0132\024.caffe.DataPar" + "ameter\022.\n\rdropout_param\030\014 \001(\0132\027.caffe.Dr" + "opoutParameter\0223\n\020dummy_data_param\030\032 \001(\013" + "2\031.caffe.DummyDataParameter\022.\n\reltwise_p" + "aram\030\030 \001(\0132\027.caffe.EltwiseParameter\022&\n\te" + "xp_param\030) \001(\0132\023.caffe.ExpParameter\0221\n\017h" + "df5_data_param\030\r \001(\0132\030.caffe.HDF5DataPar" + "ameter\0225\n\021hdf5_output_param\030\016 \001(\0132\032.caff" + "e.HDF5OutputParameter\0223\n\020hinge_loss_para" + "m\030\035 \001(\0132\031.caffe.HingeLossParameter\0223\n\020im" + "age_data_param\030\017 \001(\0132\031.caffe.ImageDataPa" + "rameter\0229\n\023infogain_loss_param\030\020 \001(\0132\034.c" + "affe.InfogainLossParameter\0229\n\023inner_prod" + "uct_param\030\021 \001(\0132\034.caffe.InnerProductPara" + "meter\022&\n\tlrn_param\030\022 \001(\0132\023.caffe.LRNPara" + "meter\0225\n\021memory_data_param\030\026 \001(\0132\032.caffe" + ".MemoryDataParameter\022&\n\tmvn_param\030\" \001(\0132" + "\023.caffe.MVNParameter\022.\n\rpooling_param\030\023 " + "\001(\0132\027.caffe.PoolingParameter\022*\n\013power_pa" + "ram\030\025 \001(\0132\025.caffe.PowerParameter\022(\n\nrelu" + "_param\030\036 \001(\0132\024.caffe.ReLUParameter\022.\n\rsi" + "gmoid_param\030& \001(\0132\027.caffe.SigmoidParamet" + "er\022.\n\rsoftmax_param\030\' \001(\0132\027.caffe.Softma" + "xParameter\022*\n\013slice_param\030\037 \001(\0132\025.caffe." + "SliceParameter\022(\n\ntanh_param\030% \001(\0132\024.caf" + "fe.TanHParameter\0222\n\017threshold_param\030\031 \001(" + "\0132\031.caffe.ThresholdParameter\0225\n\021window_d" + "ata_param\030\024 \001(\0132\032.caffe.WindowDataParame" + "ter\0227\n\017transform_param\030$ \001(\0132\036.caffe.Tra" + "nsformationParameter\022(\n\nloss_param\030* \001(\013" + "2\024.caffe.LossParameter\022&\n\005layer\030\001 \001(\0132\027." + "caffe.V0LayerParameter\"\330\004\n\tLayerType\022\010\n\004" + "NONE\020\000\022\n\n\006ABSVAL\020#\022\014\n\010ACCURACY\020\001\022\n\n\006ARGM" + "AX\020\036\022\010\n\004BNLL\020\002\022\n\n\006CONCAT\020\003\022\024\n\020CONTRASTIV" + "E_LOSS\020%\022\017\n\013CONVOLUTION\020\004\022\010\n\004DATA\020\005\022\021\n\rD" + "ECONVOLUTION\020\'\022\013\n\007DROPOUT\020\006\022\016\n\nDUMMY_DAT" + "A\020 \022\022\n\016EUCLIDEAN_LOSS\020\007\022\013\n\007ELTWISE\020\031\022\007\n\003" + "EXP\020&\022\013\n\007FLATTEN\020\010\022\r\n\tHDF5_DATA\020\t\022\017\n\013HDF" + "5_OUTPUT\020\n\022\016\n\nHINGE_LOSS\020\034\022\n\n\006IM2COL\020\013\022\016" + "\n\nIMAGE_DATA\020\014\022\021\n\rINFOGAIN_LOSS\020\r\022\021\n\rINN" + "ER_PRODUCT\020\016\022\007\n\003LRN\020\017\022\017\n\013MEMORY_DATA\020\035\022\035" + "\n\031MULTINOMIAL_LOGISTIC_LOSS\020\020\022\007\n\003MVN\020\"\022\013" + "\n\007POOLING\020\021\022\t\n\005POWER\020\032\022\010\n\004RELU\020\022\022\013\n\007SIGM" + "OID\020\023\022\036\n\032SIGMOID_CROSS_ENTROPY_LOSS\020\033\022\013\n" + "\007SILENCE\020$\022\013\n\007SOFTMAX\020\024\022\020\n\014SOFTMAX_LOSS\020" + "\025\022\t\n\005SPLIT\020\026\022\t\n\005SLICE\020!\022\010\n\004TANH\020\027\022\017\n\013WIN" + "DOW_DATA\020\030\022\r\n\tTHRESHOLD\020\037\"*\n\014DimCheckMod" + "e\022\n\n\006STRICT\020\000\022\016\n\nPERMISSIVE\020\001\"\375\007\n\020V0Laye" + "rParameter\022\014\n\004name\030\001 \001(\t\022\014\n\004type\030\002 \001(\t\022\022" + "\n\nnum_output\030\003 \001(\r\022\026\n\010biasterm\030\004 \001(\010:\004tr" + "ue\022-\n\rweight_filler\030\005 \001(\0132\026.caffe.Filler" + "Parameter\022+\n\013bias_filler\030\006 \001(\0132\026.caffe.F" + "illerParameter\022\016\n\003pad\030\007 \001(\r:\0010\022\022\n\nkernel" + "size\030\010 \001(\r\022\020\n\005group\030\t \001(\r:\0011\022\021\n\006stride\030\n" + " \001(\r:\0011\0225\n\004pool\030\013 \001(\0162\".caffe.V0LayerPar" + "ameter.PoolMethod:\003MAX\022\032\n\rdropout_ratio\030" + "\014 \001(\002:\0030.5\022\025\n\nlocal_size\030\r \001(\r:\0015\022\020\n\005alp" + "ha\030\016 \001(\002:\0011\022\022\n\004beta\030\017 \001(\002:\0040.75\022\014\n\001k\030\026 \001" + "(\002:\0011\022\016\n\006source\030\020 \001(\t\022\020\n\005scale\030\021 \001(\002:\0011\022" + "\020\n\010meanfile\030\022 \001(\t\022\021\n\tbatchsize\030\023 \001(\r\022\023\n\010" + "cropsize\030\024 \001(\r:\0010\022\025\n\006mirror\030\025 \001(\010:\005false" + "\022\037\n\005blobs\0302 \003(\0132\020.caffe.BlobProto\022\020\n\010blo" + "bs_lr\0303 \003(\002\022\024\n\014weight_decay\0304 \003(\002\022\024\n\tran" + "d_skip\0305 \001(\r:\0010\022\035\n\020det_fg_threshold\0306 \001(" + "\002:\0030.5\022\035\n\020det_bg_threshold\0307 \001(\002:\0030.5\022\035\n" + "\017det_fg_fraction\0308 \001(\002:\0040.25\022\032\n\017det_cont" + "ext_pad\030: \001(\r:\0010\022\033\n\rdet_crop_mode\030; \001(\t:" + "\004warp\022\022\n\007new_num\030< \001(\005:\0010\022\027\n\014new_channel" + "s\030= \001(\005:\0010\022\025\n\nnew_height\030> \001(\005:\0010\022\024\n\tnew" + "_width\030\? \001(\005:\0010\022\035\n\016shuffle_images\030@ \001(\010:" + "\005false\022\025\n\nconcat_dim\030A \001(\r:\0011\0226\n\021hdf5_ou" + "tput_param\030\351\007 \001(\0132\032.caffe.HDF5OutputPara" + "meter\".\n\nPoolMethod\022\007\n\003MAX\020\000\022\007\n\003AVE\020\001\022\016\n" + "\nSTOCHASTIC\020\002\"W\n\016PReLUParameter\022&\n\006fille" + "r\030\001 \001(\0132\026.caffe.FillerParameter\022\035\n\016chann" + "el_shared\030\002 \001(\010:\005false\"\207\001\n\016NormalizedBBo" + "x\022\014\n\004xmin\030\001 \001(\002\022\014\n\004ymin\030\002 \001(\002\022\014\n\004xmax\030\003 " + "\001(\002\022\014\n\004ymax\030\004 \001(\002\022\r\n\005label\030\005 \001(\005\022\021\n\tdiff" + "icult\030\006 \001(\010\022\r\n\005score\030\007 \001(\002\022\014\n\004size\030\010 \001(\002" + "*\034\n\005Phase\022\t\n\005TRAIN\020\000\022\010\n\004TEST\020\001", 16870); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "caffe.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_caffe_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_caffe_2eproto_once_); +void protobuf_AddDesc_caffe_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_caffe_2eproto_once_, + &protobuf_AddDesc_caffe_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_caffe_2eproto { + StaticDescriptorInitializer_caffe_2eproto() { + protobuf_AddDesc_caffe_2eproto(); + } +} static_descriptor_initializer_caffe_2eproto_; +const ::google::protobuf::EnumDescriptor* Phase_descriptor() { + protobuf_AssignDescriptorsOnce(); + return Phase_descriptor_; +} +bool Phase_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int BlobShape::kDimFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +BlobShape::BlobShape() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.BlobShape) +} + +void BlobShape::InitAsDefaultInstance() { +} + +BlobShape::BlobShape(const BlobShape& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.BlobShape) +} + +void BlobShape::SharedCtor() { + _cached_size_ = 0; +} + +BlobShape::~BlobShape() { + // @@protoc_insertion_point(destructor:caffe.BlobShape) + SharedDtor(); +} + +void BlobShape::SharedDtor() { +} + +void BlobShape::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BlobShape::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BlobShape_descriptor_; +} + +const BlobShape& BlobShape::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed BlobShape_default_instance_; + +BlobShape* BlobShape::New(::google::protobuf::Arena* arena) const { + BlobShape* n = new BlobShape; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void BlobShape::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.BlobShape) + dim_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool BlobShape::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.BlobShape) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated int64 dim = 1 [packed = true]; + case 1: { + if (tag == 10) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_dim()))); + } else if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + 1, 10, input, this->mutable_dim()))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.BlobShape) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.BlobShape) + return false; +#undef DO_ +} + +void BlobShape::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.BlobShape) + // repeated int64 dim = 1 [packed = true]; + if (this->dim_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_dim_cached_byte_size_); + } + for (int i = 0; i < this->dim_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt64NoTag( + this->dim(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.BlobShape) +} + +::google::protobuf::uint8* BlobShape::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.BlobShape) + // repeated int64 dim = 1 [packed = true]; + if (this->dim_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 1, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _dim_cached_byte_size_, target); + } + for (int i = 0; i < this->dim_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->dim(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.BlobShape) + return target; +} + +size_t BlobShape::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.BlobShape) + size_t total_size = 0; + + // repeated int64 dim = 1 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->dim_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int64Size(this->dim(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _dim_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BlobShape::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.BlobShape) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const BlobShape* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.BlobShape) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.BlobShape) + UnsafeMergeFrom(*source); + } +} + +void BlobShape::MergeFrom(const BlobShape& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.BlobShape) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void BlobShape::UnsafeMergeFrom(const BlobShape& from) { + GOOGLE_DCHECK(&from != this); + dim_.UnsafeMergeFrom(from.dim_); + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void BlobShape::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.BlobShape) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BlobShape::CopyFrom(const BlobShape& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.BlobShape) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool BlobShape::IsInitialized() const { + + return true; +} + +void BlobShape::Swap(BlobShape* other) { + if (other == this) return; + InternalSwap(other); +} +void BlobShape::InternalSwap(BlobShape* other) { + dim_.UnsafeArenaSwap(&other->dim_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata BlobShape::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BlobShape_descriptor_; + metadata.reflection = BlobShape_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// BlobShape + +// repeated int64 dim = 1 [packed = true]; +int BlobShape::dim_size() const { + return dim_.size(); +} +void BlobShape::clear_dim() { + dim_.Clear(); +} +::google::protobuf::int64 BlobShape::dim(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobShape.dim) + return dim_.Get(index); +} +void BlobShape::set_dim(int index, ::google::protobuf::int64 value) { + dim_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobShape.dim) +} +void BlobShape::add_dim(::google::protobuf::int64 value) { + dim_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobShape.dim) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& +BlobShape::dim() const { + // @@protoc_insertion_point(field_list:caffe.BlobShape.dim) + return dim_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int64 >* +BlobShape::mutable_dim() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobShape.dim) + return &dim_; +} + +inline const BlobShape* BlobShape::internal_default_instance() { + return &BlobShape_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int BlobProto::kShapeFieldNumber; +const int BlobProto::kDataFieldNumber; +const int BlobProto::kDiffFieldNumber; +const int BlobProto::kDoubleDataFieldNumber; +const int BlobProto::kDoubleDiffFieldNumber; +const int BlobProto::kNumFieldNumber; +const int BlobProto::kChannelsFieldNumber; +const int BlobProto::kHeightFieldNumber; +const int BlobProto::kWidthFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +BlobProto::BlobProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.BlobProto) +} + +void BlobProto::InitAsDefaultInstance() { + shape_ = const_cast< ::caffe::BlobShape*>( + ::caffe::BlobShape::internal_default_instance()); +} + +BlobProto::BlobProto(const BlobProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.BlobProto) +} + +void BlobProto::SharedCtor() { + _cached_size_ = 0; + shape_ = NULL; + ::memset(&num_, 0, reinterpret_cast(&width_) - + reinterpret_cast(&num_) + sizeof(width_)); +} + +BlobProto::~BlobProto() { + // @@protoc_insertion_point(destructor:caffe.BlobProto) + SharedDtor(); +} + +void BlobProto::SharedDtor() { + if (this != &BlobProto_default_instance_.get()) { + delete shape_; + } +} + +void BlobProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BlobProto::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BlobProto_descriptor_; +} + +const BlobProto& BlobProto::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed BlobProto_default_instance_; + +BlobProto* BlobProto::New(::google::protobuf::Arena* arena) const { + BlobProto* n = new BlobProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void BlobProto::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.BlobProto) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(BlobProto, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 225u) { + ZR_(num_, height_); + if (has_shape()) { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + } + } + width_ = 0; + +#undef ZR_HELPER_ +#undef ZR_ + + data_.Clear(); + diff_.Clear(); + double_data_.Clear(); + double_diff_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool BlobProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.BlobProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 num = 1 [default = 0]; + case 1: { + if (tag == 8) { + set_has_num(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &num_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_channels; + break; + } + + // optional int32 channels = 2 [default = 0]; + case 2: { + if (tag == 16) { + parse_channels: + set_has_channels(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &channels_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_height; + break; + } + + // optional int32 height = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_height: + set_has_height(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &height_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_width; + break; + } + + // optional int32 width = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_width: + set_has_width(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &width_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_data; + break; + } + + // repeated float data = 5 [packed = true]; + case 5: { + if (tag == 42) { + parse_data: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_data()))); + } else if (tag == 45) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 42, input, this->mutable_data()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_diff; + break; + } + + // repeated float diff = 6 [packed = true]; + case 6: { + if (tag == 50) { + parse_diff: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_diff()))); + } else if (tag == 53) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 50, input, this->mutable_diff()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_shape; + break; + } + + // optional .caffe.BlobShape shape = 7; + case 7: { + if (tag == 58) { + parse_shape: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_double_data; + break; + } + + // repeated double double_data = 8 [packed = true]; + case 8: { + if (tag == 66) { + parse_double_data: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_data()))); + } else if (tag == 65) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 66, input, this->mutable_double_data()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(74)) goto parse_double_diff; + break; + } + + // repeated double double_diff = 9 [packed = true]; + case 9: { + if (tag == 74) { + parse_double_diff: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_diff()))); + } else if (tag == 73) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 74, input, this->mutable_double_diff()))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.BlobProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.BlobProto) + return false; +#undef DO_ +} + +void BlobProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.BlobProto) + // optional int32 num = 1 [default = 0]; + if (has_num()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->num(), output); + } + + // optional int32 channels = 2 [default = 0]; + if (has_channels()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->channels(), output); + } + + // optional int32 height = 3 [default = 0]; + if (has_height()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->height(), output); + } + + // optional int32 width = 4 [default = 0]; + if (has_width()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->width(), output); + } + + // repeated float data = 5 [packed = true]; + if (this->data_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_data_cached_byte_size_); + } + for (int i = 0; i < this->data_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloatNoTag( + this->data(i), output); + } + + // repeated float diff = 6 [packed = true]; + if (this->diff_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_diff_cached_byte_size_); + } + for (int i = 0; i < this->diff_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloatNoTag( + this->diff(i), output); + } + + // optional .caffe.BlobShape shape = 7; + if (has_shape()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, *this->shape_, output); + } + + // repeated double double_data = 8 [packed = true]; + if (this->double_data_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(8, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_data_cached_byte_size_); + } + for (int i = 0; i < this->double_data_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteDoubleNoTag( + this->double_data(i), output); + } + + // repeated double double_diff = 9 [packed = true]; + if (this->double_diff_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_diff_cached_byte_size_); + } + for (int i = 0; i < this->double_diff_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteDoubleNoTag( + this->double_diff(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.BlobProto) +} + +::google::protobuf::uint8* BlobProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.BlobProto) + // optional int32 num = 1 [default = 0]; + if (has_num()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->num(), target); + } + + // optional int32 channels = 2 [default = 0]; + if (has_channels()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->channels(), target); + } + + // optional int32 height = 3 [default = 0]; + if (has_height()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->height(), target); + } + + // optional int32 width = 4 [default = 0]; + if (has_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->width(), target); + } + + // repeated float data = 5 [packed = true]; + if (this->data_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 5, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _data_cached_byte_size_, target); + } + for (int i = 0; i < this->data_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->data(i), target); + } + + // repeated float diff = 6 [packed = true]; + if (this->diff_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 6, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _diff_cached_byte_size_, target); + } + for (int i = 0; i < this->diff_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->diff(i), target); + } + + // optional .caffe.BlobShape shape = 7; + if (has_shape()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 7, *this->shape_, false, target); + } + + // repeated double double_data = 8 [packed = true]; + if (this->double_data_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 8, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _double_data_cached_byte_size_, target); + } + for (int i = 0; i < this->double_data_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_data(i), target); + } + + // repeated double double_diff = 9 [packed = true]; + if (this->double_diff_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 9, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _double_diff_cached_byte_size_, target); + } + for (int i = 0; i < this->double_diff_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_diff(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.BlobProto) + return target; +} + +size_t BlobProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.BlobProto) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 225u) { + // optional .caffe.BlobShape shape = 7; + if (has_shape()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->shape_); + } + + // optional int32 num = 1 [default = 0]; + if (has_num()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->num()); + } + + // optional int32 channels = 2 [default = 0]; + if (has_channels()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->channels()); + } + + // optional int32 height = 3 [default = 0]; + if (has_height()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->height()); + } + + } + // optional int32 width = 4 [default = 0]; + if (has_width()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->width()); + } + + // repeated float data = 5 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->data_size(); + data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _data_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated float diff = 6 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->diff_size(); + data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _diff_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated double double_data = 8 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->double_data_size(); + data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _double_data_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated double double_diff = 9 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->double_diff_size(); + data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _double_diff_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BlobProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.BlobProto) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const BlobProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.BlobProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.BlobProto) + UnsafeMergeFrom(*source); + } +} + +void BlobProto::MergeFrom(const BlobProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.BlobProto) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void BlobProto::UnsafeMergeFrom(const BlobProto& from) { + GOOGLE_DCHECK(&from != this); + data_.UnsafeMergeFrom(from.data_); + diff_.UnsafeMergeFrom(from.diff_); + double_data_.UnsafeMergeFrom(from.double_data_); + double_diff_.UnsafeMergeFrom(from.double_diff_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_shape()) { + mutable_shape()->::caffe::BlobShape::MergeFrom(from.shape()); + } + if (from.has_num()) { + set_num(from.num()); + } + if (from.has_channels()) { + set_channels(from.channels()); + } + if (from.has_height()) { + set_height(from.height()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_width()) { + set_width(from.width()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void BlobProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.BlobProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BlobProto::CopyFrom(const BlobProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.BlobProto) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool BlobProto::IsInitialized() const { + + return true; +} + +void BlobProto::Swap(BlobProto* other) { + if (other == this) return; + InternalSwap(other); +} +void BlobProto::InternalSwap(BlobProto* other) { + std::swap(shape_, other->shape_); + data_.UnsafeArenaSwap(&other->data_); + diff_.UnsafeArenaSwap(&other->diff_); + double_data_.UnsafeArenaSwap(&other->double_data_); + double_diff_.UnsafeArenaSwap(&other->double_diff_); + std::swap(num_, other->num_); + std::swap(channels_, other->channels_); + std::swap(height_, other->height_); + std::swap(width_, other->width_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata BlobProto::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BlobProto_descriptor_; + metadata.reflection = BlobProto_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// BlobProto + +// optional .caffe.BlobShape shape = 7; +bool BlobProto::has_shape() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void BlobProto::set_has_shape() { + _has_bits_[0] |= 0x00000001u; +} +void BlobProto::clear_has_shape() { + _has_bits_[0] &= ~0x00000001u; +} +void BlobProto::clear_shape() { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + clear_has_shape(); +} +const ::caffe::BlobShape& BlobProto::shape() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.shape) + return shape_ != NULL ? *shape_ + : *::caffe::BlobShape::internal_default_instance(); +} +::caffe::BlobShape* BlobProto::mutable_shape() { + set_has_shape(); + if (shape_ == NULL) { + shape_ = new ::caffe::BlobShape; + } + // @@protoc_insertion_point(field_mutable:caffe.BlobProto.shape) + return shape_; +} +::caffe::BlobShape* BlobProto::release_shape() { + // @@protoc_insertion_point(field_release:caffe.BlobProto.shape) + clear_has_shape(); + ::caffe::BlobShape* temp = shape_; + shape_ = NULL; + return temp; +} +void BlobProto::set_allocated_shape(::caffe::BlobShape* shape) { + delete shape_; + shape_ = shape; + if (shape) { + set_has_shape(); + } else { + clear_has_shape(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.BlobProto.shape) +} + +// repeated float data = 5 [packed = true]; +int BlobProto::data_size() const { + return data_.size(); +} +void BlobProto::clear_data() { + data_.Clear(); +} +float BlobProto::data(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.data) + return data_.Get(index); +} +void BlobProto::set_data(int index, float value) { + data_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.data) +} +void BlobProto::add_data(float value) { + data_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.data) +} +const ::google::protobuf::RepeatedField< float >& +BlobProto::data() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.data) + return data_; +} +::google::protobuf::RepeatedField< float >* +BlobProto::mutable_data() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.data) + return &data_; +} + +// repeated float diff = 6 [packed = true]; +int BlobProto::diff_size() const { + return diff_.size(); +} +void BlobProto::clear_diff() { + diff_.Clear(); +} +float BlobProto::diff(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.diff) + return diff_.Get(index); +} +void BlobProto::set_diff(int index, float value) { + diff_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.diff) +} +void BlobProto::add_diff(float value) { + diff_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.diff) +} +const ::google::protobuf::RepeatedField< float >& +BlobProto::diff() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.diff) + return diff_; +} +::google::protobuf::RepeatedField< float >* +BlobProto::mutable_diff() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.diff) + return &diff_; +} + +// repeated double double_data = 8 [packed = true]; +int BlobProto::double_data_size() const { + return double_data_.size(); +} +void BlobProto::clear_double_data() { + double_data_.Clear(); +} +double BlobProto::double_data(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.double_data) + return double_data_.Get(index); +} +void BlobProto::set_double_data(int index, double value) { + double_data_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.double_data) +} +void BlobProto::add_double_data(double value) { + double_data_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.double_data) +} +const ::google::protobuf::RepeatedField< double >& +BlobProto::double_data() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.double_data) + return double_data_; +} +::google::protobuf::RepeatedField< double >* +BlobProto::mutable_double_data() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.double_data) + return &double_data_; +} + +// repeated double double_diff = 9 [packed = true]; +int BlobProto::double_diff_size() const { + return double_diff_.size(); +} +void BlobProto::clear_double_diff() { + double_diff_.Clear(); +} +double BlobProto::double_diff(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.double_diff) + return double_diff_.Get(index); +} +void BlobProto::set_double_diff(int index, double value) { + double_diff_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.double_diff) +} +void BlobProto::add_double_diff(double value) { + double_diff_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.double_diff) +} +const ::google::protobuf::RepeatedField< double >& +BlobProto::double_diff() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.double_diff) + return double_diff_; +} +::google::protobuf::RepeatedField< double >* +BlobProto::mutable_double_diff() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.double_diff) + return &double_diff_; +} + +// optional int32 num = 1 [default = 0]; +bool BlobProto::has_num() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void BlobProto::set_has_num() { + _has_bits_[0] |= 0x00000020u; +} +void BlobProto::clear_has_num() { + _has_bits_[0] &= ~0x00000020u; +} +void BlobProto::clear_num() { + num_ = 0; + clear_has_num(); +} +::google::protobuf::int32 BlobProto::num() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.num) + return num_; +} +void BlobProto::set_num(::google::protobuf::int32 value) { + set_has_num(); + num_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.num) +} + +// optional int32 channels = 2 [default = 0]; +bool BlobProto::has_channels() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void BlobProto::set_has_channels() { + _has_bits_[0] |= 0x00000040u; +} +void BlobProto::clear_has_channels() { + _has_bits_[0] &= ~0x00000040u; +} +void BlobProto::clear_channels() { + channels_ = 0; + clear_has_channels(); +} +::google::protobuf::int32 BlobProto::channels() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.channels) + return channels_; +} +void BlobProto::set_channels(::google::protobuf::int32 value) { + set_has_channels(); + channels_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.channels) +} + +// optional int32 height = 3 [default = 0]; +bool BlobProto::has_height() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void BlobProto::set_has_height() { + _has_bits_[0] |= 0x00000080u; +} +void BlobProto::clear_has_height() { + _has_bits_[0] &= ~0x00000080u; +} +void BlobProto::clear_height() { + height_ = 0; + clear_has_height(); +} +::google::protobuf::int32 BlobProto::height() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.height) + return height_; +} +void BlobProto::set_height(::google::protobuf::int32 value) { + set_has_height(); + height_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.height) +} + +// optional int32 width = 4 [default = 0]; +bool BlobProto::has_width() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void BlobProto::set_has_width() { + _has_bits_[0] |= 0x00000100u; +} +void BlobProto::clear_has_width() { + _has_bits_[0] &= ~0x00000100u; +} +void BlobProto::clear_width() { + width_ = 0; + clear_has_width(); +} +::google::protobuf::int32 BlobProto::width() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.width) + return width_; +} +void BlobProto::set_width(::google::protobuf::int32 value) { + set_has_width(); + width_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.width) +} + +inline const BlobProto* BlobProto::internal_default_instance() { + return &BlobProto_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int BlobProtoVector::kBlobsFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +BlobProtoVector::BlobProtoVector() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.BlobProtoVector) +} + +void BlobProtoVector::InitAsDefaultInstance() { +} + +BlobProtoVector::BlobProtoVector(const BlobProtoVector& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.BlobProtoVector) +} + +void BlobProtoVector::SharedCtor() { + _cached_size_ = 0; +} + +BlobProtoVector::~BlobProtoVector() { + // @@protoc_insertion_point(destructor:caffe.BlobProtoVector) + SharedDtor(); +} + +void BlobProtoVector::SharedDtor() { +} + +void BlobProtoVector::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BlobProtoVector::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BlobProtoVector_descriptor_; +} + +const BlobProtoVector& BlobProtoVector::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed BlobProtoVector_default_instance_; + +BlobProtoVector* BlobProtoVector::New(::google::protobuf::Arena* arena) const { + BlobProtoVector* n = new BlobProtoVector; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void BlobProtoVector::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.BlobProtoVector) + blobs_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool BlobProtoVector::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.BlobProtoVector) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .caffe.BlobProto blobs = 1; + case 1: { + if (tag == 10) { + DO_(input->IncrementRecursionDepth()); + parse_loop_blobs: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_blobs())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_loop_blobs; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.BlobProtoVector) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.BlobProtoVector) + return false; +#undef DO_ +} + +void BlobProtoVector::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.BlobProtoVector) + // repeated .caffe.BlobProto blobs = 1; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->blobs(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.BlobProtoVector) +} + +::google::protobuf::uint8* BlobProtoVector::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.BlobProtoVector) + // repeated .caffe.BlobProto blobs = 1; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, this->blobs(i), false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.BlobProtoVector) + return target; +} + +size_t BlobProtoVector::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.BlobProtoVector) + size_t total_size = 0; + + // repeated .caffe.BlobProto blobs = 1; + { + unsigned int count = this->blobs_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blobs(i)); + } + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BlobProtoVector::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.BlobProtoVector) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const BlobProtoVector* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.BlobProtoVector) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.BlobProtoVector) + UnsafeMergeFrom(*source); + } +} + +void BlobProtoVector::MergeFrom(const BlobProtoVector& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.BlobProtoVector) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void BlobProtoVector::UnsafeMergeFrom(const BlobProtoVector& from) { + GOOGLE_DCHECK(&from != this); + blobs_.MergeFrom(from.blobs_); + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void BlobProtoVector::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.BlobProtoVector) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BlobProtoVector::CopyFrom(const BlobProtoVector& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.BlobProtoVector) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool BlobProtoVector::IsInitialized() const { + + return true; +} + +void BlobProtoVector::Swap(BlobProtoVector* other) { + if (other == this) return; + InternalSwap(other); +} +void BlobProtoVector::InternalSwap(BlobProtoVector* other) { + blobs_.UnsafeArenaSwap(&other->blobs_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata BlobProtoVector::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BlobProtoVector_descriptor_; + metadata.reflection = BlobProtoVector_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// BlobProtoVector + +// repeated .caffe.BlobProto blobs = 1; +int BlobProtoVector::blobs_size() const { + return blobs_.size(); +} +void BlobProtoVector::clear_blobs() { + blobs_.Clear(); +} +const ::caffe::BlobProto& BlobProtoVector::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProtoVector.blobs) + return blobs_.Get(index); +} +::caffe::BlobProto* BlobProtoVector::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.BlobProtoVector.blobs) + return blobs_.Mutable(index); +} +::caffe::BlobProto* BlobProtoVector::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.BlobProtoVector.blobs) + return blobs_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +BlobProtoVector::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProtoVector.blobs) + return &blobs_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +BlobProtoVector::blobs() const { + // @@protoc_insertion_point(field_list:caffe.BlobProtoVector.blobs) + return blobs_; +} + +inline const BlobProtoVector* BlobProtoVector::internal_default_instance() { + return &BlobProtoVector_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int PermuteParameter::kOrderFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +PermuteParameter::PermuteParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.PermuteParameter) +} + +void PermuteParameter::InitAsDefaultInstance() { +} + +PermuteParameter::PermuteParameter(const PermuteParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.PermuteParameter) +} + +void PermuteParameter::SharedCtor() { + _cached_size_ = 0; +} + +PermuteParameter::~PermuteParameter() { + // @@protoc_insertion_point(destructor:caffe.PermuteParameter) + SharedDtor(); +} + +void PermuteParameter::SharedDtor() { +} + +void PermuteParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PermuteParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PermuteParameter_descriptor_; +} + +const PermuteParameter& PermuteParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed PermuteParameter_default_instance_; + +PermuteParameter* PermuteParameter::New(::google::protobuf::Arena* arena) const { + PermuteParameter* n = new PermuteParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void PermuteParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.PermuteParameter) + order_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool PermuteParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.PermuteParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated uint32 order = 1; + case 1: { + if (tag == 8) { + parse_order: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 8, input, this->mutable_order()))); + } else if (tag == 10) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_order()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(8)) goto parse_order; + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.PermuteParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.PermuteParameter) + return false; +#undef DO_ +} + +void PermuteParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.PermuteParameter) + // repeated uint32 order = 1; + for (int i = 0; i < this->order_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 1, this->order(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.PermuteParameter) +} + +::google::protobuf::uint8* PermuteParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.PermuteParameter) + // repeated uint32 order = 1; + for (int i = 0; i < this->order_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(1, this->order(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.PermuteParameter) + return target; +} + +size_t PermuteParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.PermuteParameter) + size_t total_size = 0; + + // repeated uint32 order = 1; + { + size_t data_size = 0; + unsigned int count = this->order_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->order(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->order_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PermuteParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.PermuteParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const PermuteParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.PermuteParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.PermuteParameter) + UnsafeMergeFrom(*source); + } +} + +void PermuteParameter::MergeFrom(const PermuteParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.PermuteParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void PermuteParameter::UnsafeMergeFrom(const PermuteParameter& from) { + GOOGLE_DCHECK(&from != this); + order_.UnsafeMergeFrom(from.order_); + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void PermuteParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.PermuteParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PermuteParameter::CopyFrom(const PermuteParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.PermuteParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool PermuteParameter::IsInitialized() const { + + return true; +} + +void PermuteParameter::Swap(PermuteParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void PermuteParameter::InternalSwap(PermuteParameter* other) { + order_.UnsafeArenaSwap(&other->order_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata PermuteParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PermuteParameter_descriptor_; + metadata.reflection = PermuteParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// PermuteParameter + +// repeated uint32 order = 1; +int PermuteParameter::order_size() const { + return order_.size(); +} +void PermuteParameter::clear_order() { + order_.Clear(); +} +::google::protobuf::uint32 PermuteParameter::order(int index) const { + // @@protoc_insertion_point(field_get:caffe.PermuteParameter.order) + return order_.Get(index); +} +void PermuteParameter::set_order(int index, ::google::protobuf::uint32 value) { + order_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.PermuteParameter.order) +} +void PermuteParameter::add_order(::google::protobuf::uint32 value) { + order_.Add(value); + // @@protoc_insertion_point(field_add:caffe.PermuteParameter.order) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +PermuteParameter::order() const { + // @@protoc_insertion_point(field_list:caffe.PermuteParameter.order) + return order_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +PermuteParameter::mutable_order() { + // @@protoc_insertion_point(field_mutable_list:caffe.PermuteParameter.order) + return &order_; +} + +inline const PermuteParameter* PermuteParameter::internal_default_instance() { + return &PermuteParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NormalizeBBoxParameter::kAcrossSpatialFieldNumber; +const int NormalizeBBoxParameter::kScaleFillerFieldNumber; +const int NormalizeBBoxParameter::kChannelSharedFieldNumber; +const int NormalizeBBoxParameter::kEpsFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NormalizeBBoxParameter::NormalizeBBoxParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.NormalizeBBoxParameter) +} + +void NormalizeBBoxParameter::InitAsDefaultInstance() { + scale_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +NormalizeBBoxParameter::NormalizeBBoxParameter(const NormalizeBBoxParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.NormalizeBBoxParameter) +} + +void NormalizeBBoxParameter::SharedCtor() { + _cached_size_ = 0; + scale_filler_ = NULL; + across_spatial_ = true; + channel_shared_ = true; + eps_ = 1e-10f; +} + +NormalizeBBoxParameter::~NormalizeBBoxParameter() { + // @@protoc_insertion_point(destructor:caffe.NormalizeBBoxParameter) + SharedDtor(); +} + +void NormalizeBBoxParameter::SharedDtor() { + if (this != &NormalizeBBoxParameter_default_instance_.get()) { + delete scale_filler_; + } +} + +void NormalizeBBoxParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NormalizeBBoxParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NormalizeBBoxParameter_descriptor_; +} + +const NormalizeBBoxParameter& NormalizeBBoxParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NormalizeBBoxParameter_default_instance_; + +NormalizeBBoxParameter* NormalizeBBoxParameter::New(::google::protobuf::Arena* arena) const { + NormalizeBBoxParameter* n = new NormalizeBBoxParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void NormalizeBBoxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.NormalizeBBoxParameter) + if (_has_bits_[0 / 32] & 15u) { + across_spatial_ = true; + if (has_scale_filler()) { + if (scale_filler_ != NULL) scale_filler_->::caffe::FillerParameter::Clear(); + } + channel_shared_ = true; + eps_ = 1e-10f; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool NormalizeBBoxParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.NormalizeBBoxParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bool across_spatial = 1 [default = true]; + case 1: { + if (tag == 8) { + set_has_across_spatial(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &across_spatial_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_scale_filler; + break; + } + + // optional .caffe.FillerParameter scale_filler = 2; + case 2: { + if (tag == 18) { + parse_scale_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_scale_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_channel_shared; + break; + } + + // optional bool channel_shared = 3 [default = true]; + case 3: { + if (tag == 24) { + parse_channel_shared: + set_has_channel_shared(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &channel_shared_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_eps; + break; + } + + // optional float eps = 4 [default = 1e-10]; + case 4: { + if (tag == 37) { + parse_eps: + set_has_eps(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &eps_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.NormalizeBBoxParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.NormalizeBBoxParameter) + return false; +#undef DO_ +} + +void NormalizeBBoxParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.NormalizeBBoxParameter) + // optional bool across_spatial = 1 [default = true]; + if (has_across_spatial()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->across_spatial(), output); + } + + // optional .caffe.FillerParameter scale_filler = 2; + if (has_scale_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *this->scale_filler_, output); + } + + // optional bool channel_shared = 3 [default = true]; + if (has_channel_shared()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->channel_shared(), output); + } + + // optional float eps = 4 [default = 1e-10]; + if (has_eps()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->eps(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.NormalizeBBoxParameter) +} + +::google::protobuf::uint8* NormalizeBBoxParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.NormalizeBBoxParameter) + // optional bool across_spatial = 1 [default = true]; + if (has_across_spatial()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->across_spatial(), target); + } + + // optional .caffe.FillerParameter scale_filler = 2; + if (has_scale_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, *this->scale_filler_, false, target); + } + + // optional bool channel_shared = 3 [default = true]; + if (has_channel_shared()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->channel_shared(), target); + } + + // optional float eps = 4 [default = 1e-10]; + if (has_eps()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->eps(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.NormalizeBBoxParameter) + return target; +} + +size_t NormalizeBBoxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.NormalizeBBoxParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 15u) { + // optional bool across_spatial = 1 [default = true]; + if (has_across_spatial()) { + total_size += 1 + 1; + } + + // optional .caffe.FillerParameter scale_filler = 2; + if (has_scale_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->scale_filler_); + } + + // optional bool channel_shared = 3 [default = true]; + if (has_channel_shared()) { + total_size += 1 + 1; + } + + // optional float eps = 4 [default = 1e-10]; + if (has_eps()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NormalizeBBoxParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.NormalizeBBoxParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NormalizeBBoxParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.NormalizeBBoxParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.NormalizeBBoxParameter) + UnsafeMergeFrom(*source); + } +} + +void NormalizeBBoxParameter::MergeFrom(const NormalizeBBoxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.NormalizeBBoxParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NormalizeBBoxParameter::UnsafeMergeFrom(const NormalizeBBoxParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_across_spatial()) { + set_across_spatial(from.across_spatial()); + } + if (from.has_scale_filler()) { + mutable_scale_filler()->::caffe::FillerParameter::MergeFrom(from.scale_filler()); + } + if (from.has_channel_shared()) { + set_channel_shared(from.channel_shared()); + } + if (from.has_eps()) { + set_eps(from.eps()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void NormalizeBBoxParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.NormalizeBBoxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NormalizeBBoxParameter::CopyFrom(const NormalizeBBoxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.NormalizeBBoxParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NormalizeBBoxParameter::IsInitialized() const { + + return true; +} + +void NormalizeBBoxParameter::Swap(NormalizeBBoxParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void NormalizeBBoxParameter::InternalSwap(NormalizeBBoxParameter* other) { + std::swap(across_spatial_, other->across_spatial_); + std::swap(scale_filler_, other->scale_filler_); + std::swap(channel_shared_, other->channel_shared_); + std::swap(eps_, other->eps_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NormalizeBBoxParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NormalizeBBoxParameter_descriptor_; + metadata.reflection = NormalizeBBoxParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NormalizeBBoxParameter + +// optional bool across_spatial = 1 [default = true]; +bool NormalizeBBoxParameter::has_across_spatial() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void NormalizeBBoxParameter::set_has_across_spatial() { + _has_bits_[0] |= 0x00000001u; +} +void NormalizeBBoxParameter::clear_has_across_spatial() { + _has_bits_[0] &= ~0x00000001u; +} +void NormalizeBBoxParameter::clear_across_spatial() { + across_spatial_ = true; + clear_has_across_spatial(); +} +bool NormalizeBBoxParameter::across_spatial() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.across_spatial) + return across_spatial_; +} +void NormalizeBBoxParameter::set_across_spatial(bool value) { + set_has_across_spatial(); + across_spatial_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizeBBoxParameter.across_spatial) +} + +// optional .caffe.FillerParameter scale_filler = 2; +bool NormalizeBBoxParameter::has_scale_filler() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void NormalizeBBoxParameter::set_has_scale_filler() { + _has_bits_[0] |= 0x00000002u; +} +void NormalizeBBoxParameter::clear_has_scale_filler() { + _has_bits_[0] &= ~0x00000002u; +} +void NormalizeBBoxParameter::clear_scale_filler() { + if (scale_filler_ != NULL) scale_filler_->::caffe::FillerParameter::Clear(); + clear_has_scale_filler(); +} +const ::caffe::FillerParameter& NormalizeBBoxParameter::scale_filler() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.scale_filler) + return scale_filler_ != NULL ? *scale_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* NormalizeBBoxParameter::mutable_scale_filler() { + set_has_scale_filler(); + if (scale_filler_ == NULL) { + scale_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.NormalizeBBoxParameter.scale_filler) + return scale_filler_; +} +::caffe::FillerParameter* NormalizeBBoxParameter::release_scale_filler() { + // @@protoc_insertion_point(field_release:caffe.NormalizeBBoxParameter.scale_filler) + clear_has_scale_filler(); + ::caffe::FillerParameter* temp = scale_filler_; + scale_filler_ = NULL; + return temp; +} +void NormalizeBBoxParameter::set_allocated_scale_filler(::caffe::FillerParameter* scale_filler) { + delete scale_filler_; + scale_filler_ = scale_filler; + if (scale_filler) { + set_has_scale_filler(); + } else { + clear_has_scale_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.NormalizeBBoxParameter.scale_filler) +} + +// optional bool channel_shared = 3 [default = true]; +bool NormalizeBBoxParameter::has_channel_shared() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void NormalizeBBoxParameter::set_has_channel_shared() { + _has_bits_[0] |= 0x00000004u; +} +void NormalizeBBoxParameter::clear_has_channel_shared() { + _has_bits_[0] &= ~0x00000004u; +} +void NormalizeBBoxParameter::clear_channel_shared() { + channel_shared_ = true; + clear_has_channel_shared(); +} +bool NormalizeBBoxParameter::channel_shared() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.channel_shared) + return channel_shared_; +} +void NormalizeBBoxParameter::set_channel_shared(bool value) { + set_has_channel_shared(); + channel_shared_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizeBBoxParameter.channel_shared) +} + +// optional float eps = 4 [default = 1e-10]; +bool NormalizeBBoxParameter::has_eps() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void NormalizeBBoxParameter::set_has_eps() { + _has_bits_[0] |= 0x00000008u; +} +void NormalizeBBoxParameter::clear_has_eps() { + _has_bits_[0] &= ~0x00000008u; +} +void NormalizeBBoxParameter::clear_eps() { + eps_ = 1e-10f; + clear_has_eps(); +} +float NormalizeBBoxParameter::eps() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.eps) + return eps_; +} +void NormalizeBBoxParameter::set_eps(float value) { + set_has_eps(); + eps_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizeBBoxParameter.eps) +} + +inline const NormalizeBBoxParameter* NormalizeBBoxParameter::internal_default_instance() { + return &NormalizeBBoxParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* PriorBoxParameter_CodeType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return PriorBoxParameter_CodeType_descriptor_; +} +bool PriorBoxParameter_CodeType_IsValid(int value) { + switch (value) { + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const PriorBoxParameter_CodeType PriorBoxParameter::CORNER; +const PriorBoxParameter_CodeType PriorBoxParameter::CENTER_SIZE; +const PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MIN; +const PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MAX; +const int PriorBoxParameter::CodeType_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int PriorBoxParameter::kMinSizeFieldNumber; +const int PriorBoxParameter::kMaxSizeFieldNumber; +const int PriorBoxParameter::kAspectRatioFieldNumber; +const int PriorBoxParameter::kFlipFieldNumber; +const int PriorBoxParameter::kClipFieldNumber; +const int PriorBoxParameter::kVarianceFieldNumber; +const int PriorBoxParameter::kImgSizeFieldNumber; +const int PriorBoxParameter::kImgHFieldNumber; +const int PriorBoxParameter::kImgWFieldNumber; +const int PriorBoxParameter::kStepFieldNumber; +const int PriorBoxParameter::kStepHFieldNumber; +const int PriorBoxParameter::kStepWFieldNumber; +const int PriorBoxParameter::kOffsetFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +PriorBoxParameter::PriorBoxParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.PriorBoxParameter) +} + +void PriorBoxParameter::InitAsDefaultInstance() { +} + +PriorBoxParameter::PriorBoxParameter(const PriorBoxParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.PriorBoxParameter) +} + +void PriorBoxParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&min_size_, 0, reinterpret_cast(&step_w_) - + reinterpret_cast(&min_size_) + sizeof(step_w_)); + flip_ = true; + clip_ = true; + offset_ = 0.5f; +} + +PriorBoxParameter::~PriorBoxParameter() { + // @@protoc_insertion_point(destructor:caffe.PriorBoxParameter) + SharedDtor(); +} + +void PriorBoxParameter::SharedDtor() { +} + +void PriorBoxParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PriorBoxParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PriorBoxParameter_descriptor_; +} + +const PriorBoxParameter& PriorBoxParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed PriorBoxParameter_default_instance_; + +PriorBoxParameter* PriorBoxParameter::New(::google::protobuf::Arena* arena) const { + PriorBoxParameter* n = new PriorBoxParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void PriorBoxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.PriorBoxParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(PriorBoxParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 219u) { + ZR_(min_size_, img_h_); + flip_ = true; + clip_ = true; + } + if (_has_bits_[8 / 32] & 7936u) { + ZR_(img_w_, step_w_); + offset_ = 0.5f; + } + +#undef ZR_HELPER_ +#undef ZR_ + + aspect_ratio_.Clear(); + variance_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool PriorBoxParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.PriorBoxParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float min_size = 1; + case 1: { + if (tag == 13) { + set_has_min_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &min_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_max_size; + break; + } + + // optional float max_size = 2; + case 2: { + if (tag == 21) { + parse_max_size: + set_has_max_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &max_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_aspect_ratio; + break; + } + + // repeated float aspect_ratio = 3; + case 3: { + if (tag == 29) { + parse_aspect_ratio: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 29, input, this->mutable_aspect_ratio()))); + } else if (tag == 26) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_aspect_ratio()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_aspect_ratio; + if (input->ExpectTag(32)) goto parse_flip; + break; + } + + // optional bool flip = 4 [default = true]; + case 4: { + if (tag == 32) { + parse_flip: + set_has_flip(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &flip_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_clip; + break; + } + + // optional bool clip = 5 [default = true]; + case 5: { + if (tag == 40) { + parse_clip: + set_has_clip(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &clip_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(53)) goto parse_variance; + break; + } + + // repeated float variance = 6; + case 6: { + if (tag == 53) { + parse_variance: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 53, input, this->mutable_variance()))); + } else if (tag == 50) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_variance()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(53)) goto parse_variance; + if (input->ExpectTag(56)) goto parse_img_size; + break; + } + + // optional uint32 img_size = 7; + case 7: { + if (tag == 56) { + parse_img_size: + set_has_img_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &img_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_img_h; + break; + } + + // optional uint32 img_h = 8; + case 8: { + if (tag == 64) { + parse_img_h: + set_has_img_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &img_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_img_w; + break; + } + + // optional uint32 img_w = 9; + case 9: { + if (tag == 72) { + parse_img_w: + set_has_img_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &img_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(85)) goto parse_step; + break; + } + + // optional float step = 10; + case 10: { + if (tag == 85) { + parse_step: + set_has_step(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &step_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(93)) goto parse_step_h; + break; + } + + // optional float step_h = 11; + case 11: { + if (tag == 93) { + parse_step_h: + set_has_step_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &step_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(101)) goto parse_step_w; + break; + } + + // optional float step_w = 12; + case 12: { + if (tag == 101) { + parse_step_w: + set_has_step_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &step_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(109)) goto parse_offset; + break; + } + + // optional float offset = 13 [default = 0.5]; + case 13: { + if (tag == 109) { + parse_offset: + set_has_offset(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &offset_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.PriorBoxParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.PriorBoxParameter) + return false; +#undef DO_ +} + +void PriorBoxParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.PriorBoxParameter) + // optional float min_size = 1; + if (has_min_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->min_size(), output); + } + + // optional float max_size = 2; + if (has_max_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->max_size(), output); + } + + // repeated float aspect_ratio = 3; + for (int i = 0; i < this->aspect_ratio_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 3, this->aspect_ratio(i), output); + } + + // optional bool flip = 4 [default = true]; + if (has_flip()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->flip(), output); + } + + // optional bool clip = 5 [default = true]; + if (has_clip()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->clip(), output); + } + + // repeated float variance = 6; + for (int i = 0; i < this->variance_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 6, this->variance(i), output); + } + + // optional uint32 img_size = 7; + if (has_img_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->img_size(), output); + } + + // optional uint32 img_h = 8; + if (has_img_h()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->img_h(), output); + } + + // optional uint32 img_w = 9; + if (has_img_w()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->img_w(), output); + } + + // optional float step = 10; + if (has_step()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->step(), output); + } + + // optional float step_h = 11; + if (has_step_h()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->step_h(), output); + } + + // optional float step_w = 12; + if (has_step_w()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->step_w(), output); + } + + // optional float offset = 13 [default = 0.5]; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->offset(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.PriorBoxParameter) +} + +::google::protobuf::uint8* PriorBoxParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.PriorBoxParameter) + // optional float min_size = 1; + if (has_min_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->min_size(), target); + } + + // optional float max_size = 2; + if (has_max_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->max_size(), target); + } + + // repeated float aspect_ratio = 3; + for (int i = 0; i < this->aspect_ratio_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(3, this->aspect_ratio(i), target); + } + + // optional bool flip = 4 [default = true]; + if (has_flip()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->flip(), target); + } + + // optional bool clip = 5 [default = true]; + if (has_clip()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->clip(), target); + } + + // repeated float variance = 6; + for (int i = 0; i < this->variance_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(6, this->variance(i), target); + } + + // optional uint32 img_size = 7; + if (has_img_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->img_size(), target); + } + + // optional uint32 img_h = 8; + if (has_img_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->img_h(), target); + } + + // optional uint32 img_w = 9; + if (has_img_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->img_w(), target); + } + + // optional float step = 10; + if (has_step()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->step(), target); + } + + // optional float step_h = 11; + if (has_step_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->step_h(), target); + } + + // optional float step_w = 12; + if (has_step_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->step_w(), target); + } + + // optional float offset = 13 [default = 0.5]; + if (has_offset()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->offset(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.PriorBoxParameter) + return target; +} + +size_t PriorBoxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.PriorBoxParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 219u) { + // optional float min_size = 1; + if (has_min_size()) { + total_size += 1 + 4; + } + + // optional float max_size = 2; + if (has_max_size()) { + total_size += 1 + 4; + } + + // optional bool flip = 4 [default = true]; + if (has_flip()) { + total_size += 1 + 1; + } + + // optional bool clip = 5 [default = true]; + if (has_clip()) { + total_size += 1 + 1; + } + + // optional uint32 img_size = 7; + if (has_img_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->img_size()); + } + + // optional uint32 img_h = 8; + if (has_img_h()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->img_h()); + } + + } + if (_has_bits_[8 / 32] & 7936u) { + // optional uint32 img_w = 9; + if (has_img_w()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->img_w()); + } + + // optional float step = 10; + if (has_step()) { + total_size += 1 + 4; + } + + // optional float step_h = 11; + if (has_step_h()) { + total_size += 1 + 4; + } + + // optional float step_w = 12; + if (has_step_w()) { + total_size += 1 + 4; + } + + // optional float offset = 13 [default = 0.5]; + if (has_offset()) { + total_size += 1 + 4; + } + + } + // repeated float aspect_ratio = 3; + { + size_t data_size = 0; + unsigned int count = this->aspect_ratio_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->aspect_ratio_size()); + total_size += data_size; + } + + // repeated float variance = 6; + { + size_t data_size = 0; + unsigned int count = this->variance_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->variance_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PriorBoxParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.PriorBoxParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const PriorBoxParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.PriorBoxParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.PriorBoxParameter) + UnsafeMergeFrom(*source); + } +} + +void PriorBoxParameter::MergeFrom(const PriorBoxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.PriorBoxParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void PriorBoxParameter::UnsafeMergeFrom(const PriorBoxParameter& from) { + GOOGLE_DCHECK(&from != this); + aspect_ratio_.UnsafeMergeFrom(from.aspect_ratio_); + variance_.UnsafeMergeFrom(from.variance_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_min_size()) { + set_min_size(from.min_size()); + } + if (from.has_max_size()) { + set_max_size(from.max_size()); + } + if (from.has_flip()) { + set_flip(from.flip()); + } + if (from.has_clip()) { + set_clip(from.clip()); + } + if (from.has_img_size()) { + set_img_size(from.img_size()); + } + if (from.has_img_h()) { + set_img_h(from.img_h()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_img_w()) { + set_img_w(from.img_w()); + } + if (from.has_step()) { + set_step(from.step()); + } + if (from.has_step_h()) { + set_step_h(from.step_h()); + } + if (from.has_step_w()) { + set_step_w(from.step_w()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void PriorBoxParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.PriorBoxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PriorBoxParameter::CopyFrom(const PriorBoxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.PriorBoxParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool PriorBoxParameter::IsInitialized() const { + + return true; +} + +void PriorBoxParameter::Swap(PriorBoxParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void PriorBoxParameter::InternalSwap(PriorBoxParameter* other) { + std::swap(min_size_, other->min_size_); + std::swap(max_size_, other->max_size_); + aspect_ratio_.UnsafeArenaSwap(&other->aspect_ratio_); + std::swap(flip_, other->flip_); + std::swap(clip_, other->clip_); + variance_.UnsafeArenaSwap(&other->variance_); + std::swap(img_size_, other->img_size_); + std::swap(img_h_, other->img_h_); + std::swap(img_w_, other->img_w_); + std::swap(step_, other->step_); + std::swap(step_h_, other->step_h_); + std::swap(step_w_, other->step_w_); + std::swap(offset_, other->offset_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata PriorBoxParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PriorBoxParameter_descriptor_; + metadata.reflection = PriorBoxParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// PriorBoxParameter + +// optional float min_size = 1; +bool PriorBoxParameter::has_min_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void PriorBoxParameter::set_has_min_size() { + _has_bits_[0] |= 0x00000001u; +} +void PriorBoxParameter::clear_has_min_size() { + _has_bits_[0] &= ~0x00000001u; +} +void PriorBoxParameter::clear_min_size() { + min_size_ = 0; + clear_has_min_size(); +} +float PriorBoxParameter::min_size() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.min_size) + return min_size_; +} +void PriorBoxParameter::set_min_size(float value) { + set_has_min_size(); + min_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.min_size) +} + +// optional float max_size = 2; +bool PriorBoxParameter::has_max_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void PriorBoxParameter::set_has_max_size() { + _has_bits_[0] |= 0x00000002u; +} +void PriorBoxParameter::clear_has_max_size() { + _has_bits_[0] &= ~0x00000002u; +} +void PriorBoxParameter::clear_max_size() { + max_size_ = 0; + clear_has_max_size(); +} +float PriorBoxParameter::max_size() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.max_size) + return max_size_; +} +void PriorBoxParameter::set_max_size(float value) { + set_has_max_size(); + max_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.max_size) +} + +// repeated float aspect_ratio = 3; +int PriorBoxParameter::aspect_ratio_size() const { + return aspect_ratio_.size(); +} +void PriorBoxParameter::clear_aspect_ratio() { + aspect_ratio_.Clear(); +} +float PriorBoxParameter::aspect_ratio(int index) const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.aspect_ratio) + return aspect_ratio_.Get(index); +} +void PriorBoxParameter::set_aspect_ratio(int index, float value) { + aspect_ratio_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.aspect_ratio) +} +void PriorBoxParameter::add_aspect_ratio(float value) { + aspect_ratio_.Add(value); + // @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.aspect_ratio) +} +const ::google::protobuf::RepeatedField< float >& +PriorBoxParameter::aspect_ratio() const { + // @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.aspect_ratio) + return aspect_ratio_; +} +::google::protobuf::RepeatedField< float >* +PriorBoxParameter::mutable_aspect_ratio() { + // @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.aspect_ratio) + return &aspect_ratio_; +} + +// optional bool flip = 4 [default = true]; +bool PriorBoxParameter::has_flip() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void PriorBoxParameter::set_has_flip() { + _has_bits_[0] |= 0x00000008u; +} +void PriorBoxParameter::clear_has_flip() { + _has_bits_[0] &= ~0x00000008u; +} +void PriorBoxParameter::clear_flip() { + flip_ = true; + clear_has_flip(); +} +bool PriorBoxParameter::flip() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.flip) + return flip_; +} +void PriorBoxParameter::set_flip(bool value) { + set_has_flip(); + flip_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.flip) +} + +// optional bool clip = 5 [default = true]; +bool PriorBoxParameter::has_clip() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void PriorBoxParameter::set_has_clip() { + _has_bits_[0] |= 0x00000010u; +} +void PriorBoxParameter::clear_has_clip() { + _has_bits_[0] &= ~0x00000010u; +} +void PriorBoxParameter::clear_clip() { + clip_ = true; + clear_has_clip(); +} +bool PriorBoxParameter::clip() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.clip) + return clip_; +} +void PriorBoxParameter::set_clip(bool value) { + set_has_clip(); + clip_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.clip) +} + +// repeated float variance = 6; +int PriorBoxParameter::variance_size() const { + return variance_.size(); +} +void PriorBoxParameter::clear_variance() { + variance_.Clear(); +} +float PriorBoxParameter::variance(int index) const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.variance) + return variance_.Get(index); +} +void PriorBoxParameter::set_variance(int index, float value) { + variance_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.variance) +} +void PriorBoxParameter::add_variance(float value) { + variance_.Add(value); + // @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.variance) +} +const ::google::protobuf::RepeatedField< float >& +PriorBoxParameter::variance() const { + // @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.variance) + return variance_; +} +::google::protobuf::RepeatedField< float >* +PriorBoxParameter::mutable_variance() { + // @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.variance) + return &variance_; +} + +// optional uint32 img_size = 7; +bool PriorBoxParameter::has_img_size() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void PriorBoxParameter::set_has_img_size() { + _has_bits_[0] |= 0x00000040u; +} +void PriorBoxParameter::clear_has_img_size() { + _has_bits_[0] &= ~0x00000040u; +} +void PriorBoxParameter::clear_img_size() { + img_size_ = 0u; + clear_has_img_size(); +} +::google::protobuf::uint32 PriorBoxParameter::img_size() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_size) + return img_size_; +} +void PriorBoxParameter::set_img_size(::google::protobuf::uint32 value) { + set_has_img_size(); + img_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_size) +} + +// optional uint32 img_h = 8; +bool PriorBoxParameter::has_img_h() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void PriorBoxParameter::set_has_img_h() { + _has_bits_[0] |= 0x00000080u; +} +void PriorBoxParameter::clear_has_img_h() { + _has_bits_[0] &= ~0x00000080u; +} +void PriorBoxParameter::clear_img_h() { + img_h_ = 0u; + clear_has_img_h(); +} +::google::protobuf::uint32 PriorBoxParameter::img_h() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_h) + return img_h_; +} +void PriorBoxParameter::set_img_h(::google::protobuf::uint32 value) { + set_has_img_h(); + img_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_h) +} + +// optional uint32 img_w = 9; +bool PriorBoxParameter::has_img_w() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void PriorBoxParameter::set_has_img_w() { + _has_bits_[0] |= 0x00000100u; +} +void PriorBoxParameter::clear_has_img_w() { + _has_bits_[0] &= ~0x00000100u; +} +void PriorBoxParameter::clear_img_w() { + img_w_ = 0u; + clear_has_img_w(); +} +::google::protobuf::uint32 PriorBoxParameter::img_w() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_w) + return img_w_; +} +void PriorBoxParameter::set_img_w(::google::protobuf::uint32 value) { + set_has_img_w(); + img_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_w) +} + +// optional float step = 10; +bool PriorBoxParameter::has_step() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void PriorBoxParameter::set_has_step() { + _has_bits_[0] |= 0x00000200u; +} +void PriorBoxParameter::clear_has_step() { + _has_bits_[0] &= ~0x00000200u; +} +void PriorBoxParameter::clear_step() { + step_ = 0; + clear_has_step(); +} +float PriorBoxParameter::step() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step) + return step_; +} +void PriorBoxParameter::set_step(float value) { + set_has_step(); + step_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step) +} + +// optional float step_h = 11; +bool PriorBoxParameter::has_step_h() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +void PriorBoxParameter::set_has_step_h() { + _has_bits_[0] |= 0x00000400u; +} +void PriorBoxParameter::clear_has_step_h() { + _has_bits_[0] &= ~0x00000400u; +} +void PriorBoxParameter::clear_step_h() { + step_h_ = 0; + clear_has_step_h(); +} +float PriorBoxParameter::step_h() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step_h) + return step_h_; +} +void PriorBoxParameter::set_step_h(float value) { + set_has_step_h(); + step_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step_h) +} + +// optional float step_w = 12; +bool PriorBoxParameter::has_step_w() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void PriorBoxParameter::set_has_step_w() { + _has_bits_[0] |= 0x00000800u; +} +void PriorBoxParameter::clear_has_step_w() { + _has_bits_[0] &= ~0x00000800u; +} +void PriorBoxParameter::clear_step_w() { + step_w_ = 0; + clear_has_step_w(); +} +float PriorBoxParameter::step_w() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step_w) + return step_w_; +} +void PriorBoxParameter::set_step_w(float value) { + set_has_step_w(); + step_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step_w) +} + +// optional float offset = 13 [default = 0.5]; +bool PriorBoxParameter::has_offset() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +void PriorBoxParameter::set_has_offset() { + _has_bits_[0] |= 0x00001000u; +} +void PriorBoxParameter::clear_has_offset() { + _has_bits_[0] &= ~0x00001000u; +} +void PriorBoxParameter::clear_offset() { + offset_ = 0.5f; + clear_has_offset(); +} +float PriorBoxParameter::offset() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.offset) + return offset_; +} +void PriorBoxParameter::set_offset(float value) { + set_has_offset(); + offset_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.offset) +} + +inline const PriorBoxParameter* PriorBoxParameter::internal_default_instance() { + return &PriorBoxParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int DetectionOutputParameter::kNumClassesFieldNumber; +const int DetectionOutputParameter::kShareLocationFieldNumber; +const int DetectionOutputParameter::kBackgroundLabelIdFieldNumber; +const int DetectionOutputParameter::kNmsParamFieldNumber; +const int DetectionOutputParameter::kSaveOutputParamFieldNumber; +const int DetectionOutputParameter::kCodeTypeFieldNumber; +const int DetectionOutputParameter::kVarianceEncodedInTargetFieldNumber; +const int DetectionOutputParameter::kKeepTopKFieldNumber; +const int DetectionOutputParameter::kConfidenceThresholdFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +DetectionOutputParameter::DetectionOutputParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.DetectionOutputParameter) +} + +void DetectionOutputParameter::InitAsDefaultInstance() { + nms_param_ = const_cast< ::caffe::NonMaximumSuppressionParameter*>( + ::caffe::NonMaximumSuppressionParameter::internal_default_instance()); + save_output_param_ = const_cast< ::caffe::SaveOutputParameter*>( + ::caffe::SaveOutputParameter::internal_default_instance()); +} + +DetectionOutputParameter::DetectionOutputParameter(const DetectionOutputParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.DetectionOutputParameter) +} + +void DetectionOutputParameter::SharedCtor() { + _cached_size_ = 0; + nms_param_ = NULL; + save_output_param_ = NULL; + ::memset(&num_classes_, 0, reinterpret_cast(&confidence_threshold_) - + reinterpret_cast(&num_classes_) + sizeof(confidence_threshold_)); + keep_top_k_ = -1; + share_location_ = true; + code_type_ = 1; +} + +DetectionOutputParameter::~DetectionOutputParameter() { + // @@protoc_insertion_point(destructor:caffe.DetectionOutputParameter) + SharedDtor(); +} + +void DetectionOutputParameter::SharedDtor() { + if (this != &DetectionOutputParameter_default_instance_.get()) { + delete nms_param_; + delete save_output_param_; + } +} + +void DetectionOutputParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DetectionOutputParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DetectionOutputParameter_descriptor_; +} + +const DetectionOutputParameter& DetectionOutputParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed DetectionOutputParameter_default_instance_; + +DetectionOutputParameter* DetectionOutputParameter::New(::google::protobuf::Arena* arena) const { + DetectionOutputParameter* n = new DetectionOutputParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void DetectionOutputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.DetectionOutputParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(DetectionOutputParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 255u) { + ZR_(num_classes_, variance_encoded_in_target_); + share_location_ = true; + if (has_nms_param()) { + if (nms_param_ != NULL) nms_param_->::caffe::NonMaximumSuppressionParameter::Clear(); + } + if (has_save_output_param()) { + if (save_output_param_ != NULL) save_output_param_->::caffe::SaveOutputParameter::Clear(); + } + code_type_ = 1; + keep_top_k_ = -1; + } + confidence_threshold_ = 0; + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool DetectionOutputParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.DetectionOutputParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 num_classes = 1; + case 1: { + if (tag == 8) { + set_has_num_classes(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &num_classes_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_share_location; + break; + } + + // optional bool share_location = 2 [default = true]; + case 2: { + if (tag == 16) { + parse_share_location: + set_has_share_location(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &share_location_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_background_label_id; + break; + } + + // optional int32 background_label_id = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_background_label_id: + set_has_background_label_id(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &background_label_id_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_nms_param; + break; + } + + // optional .caffe.NonMaximumSuppressionParameter nms_param = 4; + case 4: { + if (tag == 34) { + parse_nms_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_nms_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_save_output_param; + break; + } + + // optional .caffe.SaveOutputParameter save_output_param = 5; + case 5: { + if (tag == 42) { + parse_save_output_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_save_output_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_code_type; + break; + } + + // optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + case 6: { + if (tag == 48) { + parse_code_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::PriorBoxParameter_CodeType_IsValid(value)) { + set_code_type(static_cast< ::caffe::PriorBoxParameter_CodeType >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_keep_top_k; + break; + } + + // optional int32 keep_top_k = 7 [default = -1]; + case 7: { + if (tag == 56) { + parse_keep_top_k: + set_has_keep_top_k(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &keep_top_k_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_variance_encoded_in_target; + break; + } + + // optional bool variance_encoded_in_target = 8 [default = false]; + case 8: { + if (tag == 64) { + parse_variance_encoded_in_target: + set_has_variance_encoded_in_target(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &variance_encoded_in_target_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(77)) goto parse_confidence_threshold; + break; + } + + // optional float confidence_threshold = 9; + case 9: { + if (tag == 77) { + parse_confidence_threshold: + set_has_confidence_threshold(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &confidence_threshold_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.DetectionOutputParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.DetectionOutputParameter) + return false; +#undef DO_ +} + +void DetectionOutputParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.DetectionOutputParameter) + // optional uint32 num_classes = 1; + if (has_num_classes()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_classes(), output); + } + + // optional bool share_location = 2 [default = true]; + if (has_share_location()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->share_location(), output); + } + + // optional int32 background_label_id = 3 [default = 0]; + if (has_background_label_id()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->background_label_id(), output); + } + + // optional .caffe.NonMaximumSuppressionParameter nms_param = 4; + if (has_nms_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, *this->nms_param_, output); + } + + // optional .caffe.SaveOutputParameter save_output_param = 5; + if (has_save_output_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *this->save_output_param_, output); + } + + // optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + if (has_code_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->code_type(), output); + } + + // optional int32 keep_top_k = 7 [default = -1]; + if (has_keep_top_k()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->keep_top_k(), output); + } + + // optional bool variance_encoded_in_target = 8 [default = false]; + if (has_variance_encoded_in_target()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->variance_encoded_in_target(), output); + } + + // optional float confidence_threshold = 9; + if (has_confidence_threshold()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->confidence_threshold(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.DetectionOutputParameter) +} + +::google::protobuf::uint8* DetectionOutputParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.DetectionOutputParameter) + // optional uint32 num_classes = 1; + if (has_num_classes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_classes(), target); + } + + // optional bool share_location = 2 [default = true]; + if (has_share_location()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->share_location(), target); + } + + // optional int32 background_label_id = 3 [default = 0]; + if (has_background_label_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->background_label_id(), target); + } + + // optional .caffe.NonMaximumSuppressionParameter nms_param = 4; + if (has_nms_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 4, *this->nms_param_, false, target); + } + + // optional .caffe.SaveOutputParameter save_output_param = 5; + if (has_save_output_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *this->save_output_param_, false, target); + } + + // optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + if (has_code_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->code_type(), target); + } + + // optional int32 keep_top_k = 7 [default = -1]; + if (has_keep_top_k()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->keep_top_k(), target); + } + + // optional bool variance_encoded_in_target = 8 [default = false]; + if (has_variance_encoded_in_target()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->variance_encoded_in_target(), target); + } + + // optional float confidence_threshold = 9; + if (has_confidence_threshold()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->confidence_threshold(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.DetectionOutputParameter) + return target; +} + +size_t DetectionOutputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.DetectionOutputParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional uint32 num_classes = 1; + if (has_num_classes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->num_classes()); + } + + // optional bool share_location = 2 [default = true]; + if (has_share_location()) { + total_size += 1 + 1; + } + + // optional int32 background_label_id = 3 [default = 0]; + if (has_background_label_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->background_label_id()); + } + + // optional .caffe.NonMaximumSuppressionParameter nms_param = 4; + if (has_nms_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->nms_param_); + } + + // optional .caffe.SaveOutputParameter save_output_param = 5; + if (has_save_output_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->save_output_param_); + } + + // optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + if (has_code_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->code_type()); + } + + // optional bool variance_encoded_in_target = 8 [default = false]; + if (has_variance_encoded_in_target()) { + total_size += 1 + 1; + } + + // optional int32 keep_top_k = 7 [default = -1]; + if (has_keep_top_k()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->keep_top_k()); + } + + } + // optional float confidence_threshold = 9; + if (has_confidence_threshold()) { + total_size += 1 + 4; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DetectionOutputParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.DetectionOutputParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const DetectionOutputParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.DetectionOutputParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.DetectionOutputParameter) + UnsafeMergeFrom(*source); + } +} + +void DetectionOutputParameter::MergeFrom(const DetectionOutputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.DetectionOutputParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void DetectionOutputParameter::UnsafeMergeFrom(const DetectionOutputParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_num_classes()) { + set_num_classes(from.num_classes()); + } + if (from.has_share_location()) { + set_share_location(from.share_location()); + } + if (from.has_background_label_id()) { + set_background_label_id(from.background_label_id()); + } + if (from.has_nms_param()) { + mutable_nms_param()->::caffe::NonMaximumSuppressionParameter::MergeFrom(from.nms_param()); + } + if (from.has_save_output_param()) { + mutable_save_output_param()->::caffe::SaveOutputParameter::MergeFrom(from.save_output_param()); + } + if (from.has_code_type()) { + set_code_type(from.code_type()); + } + if (from.has_variance_encoded_in_target()) { + set_variance_encoded_in_target(from.variance_encoded_in_target()); + } + if (from.has_keep_top_k()) { + set_keep_top_k(from.keep_top_k()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_confidence_threshold()) { + set_confidence_threshold(from.confidence_threshold()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void DetectionOutputParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.DetectionOutputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DetectionOutputParameter::CopyFrom(const DetectionOutputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.DetectionOutputParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool DetectionOutputParameter::IsInitialized() const { + + return true; +} + +void DetectionOutputParameter::Swap(DetectionOutputParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void DetectionOutputParameter::InternalSwap(DetectionOutputParameter* other) { + std::swap(num_classes_, other->num_classes_); + std::swap(share_location_, other->share_location_); + std::swap(background_label_id_, other->background_label_id_); + std::swap(nms_param_, other->nms_param_); + std::swap(save_output_param_, other->save_output_param_); + std::swap(code_type_, other->code_type_); + std::swap(variance_encoded_in_target_, other->variance_encoded_in_target_); + std::swap(keep_top_k_, other->keep_top_k_); + std::swap(confidence_threshold_, other->confidence_threshold_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata DetectionOutputParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DetectionOutputParameter_descriptor_; + metadata.reflection = DetectionOutputParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// DetectionOutputParameter + +// optional uint32 num_classes = 1; +bool DetectionOutputParameter::has_num_classes() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void DetectionOutputParameter::set_has_num_classes() { + _has_bits_[0] |= 0x00000001u; +} +void DetectionOutputParameter::clear_has_num_classes() { + _has_bits_[0] &= ~0x00000001u; +} +void DetectionOutputParameter::clear_num_classes() { + num_classes_ = 0u; + clear_has_num_classes(); +} +::google::protobuf::uint32 DetectionOutputParameter::num_classes() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.num_classes) + return num_classes_; +} +void DetectionOutputParameter::set_num_classes(::google::protobuf::uint32 value) { + set_has_num_classes(); + num_classes_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.num_classes) +} + +// optional bool share_location = 2 [default = true]; +bool DetectionOutputParameter::has_share_location() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void DetectionOutputParameter::set_has_share_location() { + _has_bits_[0] |= 0x00000002u; +} +void DetectionOutputParameter::clear_has_share_location() { + _has_bits_[0] &= ~0x00000002u; +} +void DetectionOutputParameter::clear_share_location() { + share_location_ = true; + clear_has_share_location(); +} +bool DetectionOutputParameter::share_location() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.share_location) + return share_location_; +} +void DetectionOutputParameter::set_share_location(bool value) { + set_has_share_location(); + share_location_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.share_location) +} + +// optional int32 background_label_id = 3 [default = 0]; +bool DetectionOutputParameter::has_background_label_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void DetectionOutputParameter::set_has_background_label_id() { + _has_bits_[0] |= 0x00000004u; +} +void DetectionOutputParameter::clear_has_background_label_id() { + _has_bits_[0] &= ~0x00000004u; +} +void DetectionOutputParameter::clear_background_label_id() { + background_label_id_ = 0; + clear_has_background_label_id(); +} +::google::protobuf::int32 DetectionOutputParameter::background_label_id() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.background_label_id) + return background_label_id_; +} +void DetectionOutputParameter::set_background_label_id(::google::protobuf::int32 value) { + set_has_background_label_id(); + background_label_id_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.background_label_id) +} + +// optional .caffe.NonMaximumSuppressionParameter nms_param = 4; +bool DetectionOutputParameter::has_nms_param() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void DetectionOutputParameter::set_has_nms_param() { + _has_bits_[0] |= 0x00000008u; +} +void DetectionOutputParameter::clear_has_nms_param() { + _has_bits_[0] &= ~0x00000008u; +} +void DetectionOutputParameter::clear_nms_param() { + if (nms_param_ != NULL) nms_param_->::caffe::NonMaximumSuppressionParameter::Clear(); + clear_has_nms_param(); +} +const ::caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::nms_param() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.nms_param) + return nms_param_ != NULL ? *nms_param_ + : *::caffe::NonMaximumSuppressionParameter::internal_default_instance(); +} +::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::mutable_nms_param() { + set_has_nms_param(); + if (nms_param_ == NULL) { + nms_param_ = new ::caffe::NonMaximumSuppressionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.DetectionOutputParameter.nms_param) + return nms_param_; +} +::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::release_nms_param() { + // @@protoc_insertion_point(field_release:caffe.DetectionOutputParameter.nms_param) + clear_has_nms_param(); + ::caffe::NonMaximumSuppressionParameter* temp = nms_param_; + nms_param_ = NULL; + return temp; +} +void DetectionOutputParameter::set_allocated_nms_param(::caffe::NonMaximumSuppressionParameter* nms_param) { + delete nms_param_; + nms_param_ = nms_param; + if (nms_param) { + set_has_nms_param(); + } else { + clear_has_nms_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.DetectionOutputParameter.nms_param) +} + +// optional .caffe.SaveOutputParameter save_output_param = 5; +bool DetectionOutputParameter::has_save_output_param() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void DetectionOutputParameter::set_has_save_output_param() { + _has_bits_[0] |= 0x00000010u; +} +void DetectionOutputParameter::clear_has_save_output_param() { + _has_bits_[0] &= ~0x00000010u; +} +void DetectionOutputParameter::clear_save_output_param() { + if (save_output_param_ != NULL) save_output_param_->::caffe::SaveOutputParameter::Clear(); + clear_has_save_output_param(); +} +const ::caffe::SaveOutputParameter& DetectionOutputParameter::save_output_param() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.save_output_param) + return save_output_param_ != NULL ? *save_output_param_ + : *::caffe::SaveOutputParameter::internal_default_instance(); +} +::caffe::SaveOutputParameter* DetectionOutputParameter::mutable_save_output_param() { + set_has_save_output_param(); + if (save_output_param_ == NULL) { + save_output_param_ = new ::caffe::SaveOutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.DetectionOutputParameter.save_output_param) + return save_output_param_; +} +::caffe::SaveOutputParameter* DetectionOutputParameter::release_save_output_param() { + // @@protoc_insertion_point(field_release:caffe.DetectionOutputParameter.save_output_param) + clear_has_save_output_param(); + ::caffe::SaveOutputParameter* temp = save_output_param_; + save_output_param_ = NULL; + return temp; +} +void DetectionOutputParameter::set_allocated_save_output_param(::caffe::SaveOutputParameter* save_output_param) { + delete save_output_param_; + save_output_param_ = save_output_param; + if (save_output_param) { + set_has_save_output_param(); + } else { + clear_has_save_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.DetectionOutputParameter.save_output_param) +} + +// optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; +bool DetectionOutputParameter::has_code_type() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void DetectionOutputParameter::set_has_code_type() { + _has_bits_[0] |= 0x00000020u; +} +void DetectionOutputParameter::clear_has_code_type() { + _has_bits_[0] &= ~0x00000020u; +} +void DetectionOutputParameter::clear_code_type() { + code_type_ = 1; + clear_has_code_type(); +} +::caffe::PriorBoxParameter_CodeType DetectionOutputParameter::code_type() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.code_type) + return static_cast< ::caffe::PriorBoxParameter_CodeType >(code_type_); +} +void DetectionOutputParameter::set_code_type(::caffe::PriorBoxParameter_CodeType value) { + assert(::caffe::PriorBoxParameter_CodeType_IsValid(value)); + set_has_code_type(); + code_type_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.code_type) +} + +// optional bool variance_encoded_in_target = 8 [default = false]; +bool DetectionOutputParameter::has_variance_encoded_in_target() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void DetectionOutputParameter::set_has_variance_encoded_in_target() { + _has_bits_[0] |= 0x00000040u; +} +void DetectionOutputParameter::clear_has_variance_encoded_in_target() { + _has_bits_[0] &= ~0x00000040u; +} +void DetectionOutputParameter::clear_variance_encoded_in_target() { + variance_encoded_in_target_ = false; + clear_has_variance_encoded_in_target(); +} +bool DetectionOutputParameter::variance_encoded_in_target() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.variance_encoded_in_target) + return variance_encoded_in_target_; +} +void DetectionOutputParameter::set_variance_encoded_in_target(bool value) { + set_has_variance_encoded_in_target(); + variance_encoded_in_target_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.variance_encoded_in_target) +} + +// optional int32 keep_top_k = 7 [default = -1]; +bool DetectionOutputParameter::has_keep_top_k() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void DetectionOutputParameter::set_has_keep_top_k() { + _has_bits_[0] |= 0x00000080u; +} +void DetectionOutputParameter::clear_has_keep_top_k() { + _has_bits_[0] &= ~0x00000080u; +} +void DetectionOutputParameter::clear_keep_top_k() { + keep_top_k_ = -1; + clear_has_keep_top_k(); +} +::google::protobuf::int32 DetectionOutputParameter::keep_top_k() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.keep_top_k) + return keep_top_k_; +} +void DetectionOutputParameter::set_keep_top_k(::google::protobuf::int32 value) { + set_has_keep_top_k(); + keep_top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.keep_top_k) +} + +// optional float confidence_threshold = 9; +bool DetectionOutputParameter::has_confidence_threshold() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void DetectionOutputParameter::set_has_confidence_threshold() { + _has_bits_[0] |= 0x00000100u; +} +void DetectionOutputParameter::clear_has_confidence_threshold() { + _has_bits_[0] &= ~0x00000100u; +} +void DetectionOutputParameter::clear_confidence_threshold() { + confidence_threshold_ = 0; + clear_has_confidence_threshold(); +} +float DetectionOutputParameter::confidence_threshold() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.confidence_threshold) + return confidence_threshold_; +} +void DetectionOutputParameter::set_confidence_threshold(float value) { + set_has_confidence_threshold(); + confidence_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.confidence_threshold) +} + +inline const DetectionOutputParameter* DetectionOutputParameter::internal_default_instance() { + return &DetectionOutputParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int Datum::kChannelsFieldNumber; +const int Datum::kHeightFieldNumber; +const int Datum::kWidthFieldNumber; +const int Datum::kDataFieldNumber; +const int Datum::kLabelFieldNumber; +const int Datum::kFloatDataFieldNumber; +const int Datum::kEncodedFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +Datum::Datum() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.Datum) +} + +void Datum::InitAsDefaultInstance() { +} + +Datum::Datum(const Datum& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.Datum) +} + +void Datum::SharedCtor() { + _cached_size_ = 0; + data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&channels_, 0, reinterpret_cast(&encoded_) - + reinterpret_cast(&channels_) + sizeof(encoded_)); +} + +Datum::~Datum() { + // @@protoc_insertion_point(destructor:caffe.Datum) + SharedDtor(); +} + +void Datum::SharedDtor() { + data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void Datum::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Datum::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Datum_descriptor_; +} + +const Datum& Datum::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed Datum_default_instance_; + +Datum* Datum::New(::google::protobuf::Arena* arena) const { + Datum* n = new Datum; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void Datum::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.Datum) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(Datum, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 95u) { + ZR_(channels_, encoded_); + if (has_data()) { + data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + float_data_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool Datum::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.Datum) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 channels = 1; + case 1: { + if (tag == 8) { + set_has_channels(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &channels_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_height; + break; + } + + // optional int32 height = 2; + case 2: { + if (tag == 16) { + parse_height: + set_has_height(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &height_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_width; + break; + } + + // optional int32 width = 3; + case 3: { + if (tag == 24) { + parse_width: + set_has_width(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &width_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_data; + break; + } + + // optional bytes data = 4; + case 4: { + if (tag == 34) { + parse_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_data())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_label; + break; + } + + // optional int32 label = 5; + case 5: { + if (tag == 40) { + parse_label: + set_has_label(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &label_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(53)) goto parse_float_data; + break; + } + + // repeated float float_data = 6; + case 6: { + if (tag == 53) { + parse_float_data: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 53, input, this->mutable_float_data()))); + } else if (tag == 50) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_float_data()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(53)) goto parse_float_data; + if (input->ExpectTag(56)) goto parse_encoded; + break; + } + + // optional bool encoded = 7 [default = false]; + case 7: { + if (tag == 56) { + parse_encoded: + set_has_encoded(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &encoded_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.Datum) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.Datum) + return false; +#undef DO_ +} + +void Datum::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.Datum) + // optional int32 channels = 1; + if (has_channels()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->channels(), output); + } + + // optional int32 height = 2; + if (has_height()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->height(), output); + } + + // optional int32 width = 3; + if (has_width()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->width(), output); + } + + // optional bytes data = 4; + if (has_data()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 4, this->data(), output); + } + + // optional int32 label = 5; + if (has_label()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->label(), output); + } + + // repeated float float_data = 6; + for (int i = 0; i < this->float_data_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 6, this->float_data(i), output); + } + + // optional bool encoded = 7 [default = false]; + if (has_encoded()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->encoded(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.Datum) +} + +::google::protobuf::uint8* Datum::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.Datum) + // optional int32 channels = 1; + if (has_channels()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->channels(), target); + } + + // optional int32 height = 2; + if (has_height()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->height(), target); + } + + // optional int32 width = 3; + if (has_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->width(), target); + } + + // optional bytes data = 4; + if (has_data()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 4, this->data(), target); + } + + // optional int32 label = 5; + if (has_label()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->label(), target); + } + + // repeated float float_data = 6; + for (int i = 0; i < this->float_data_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(6, this->float_data(i), target); + } + + // optional bool encoded = 7 [default = false]; + if (has_encoded()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->encoded(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.Datum) + return target; +} + +size_t Datum::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.Datum) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 95u) { + // optional int32 channels = 1; + if (has_channels()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->channels()); + } + + // optional int32 height = 2; + if (has_height()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->height()); + } + + // optional int32 width = 3; + if (has_width()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->width()); + } + + // optional bytes data = 4; + if (has_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->data()); + } + + // optional int32 label = 5; + if (has_label()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->label()); + } + + // optional bool encoded = 7 [default = false]; + if (has_encoded()) { + total_size += 1 + 1; + } + + } + // repeated float float_data = 6; + { + size_t data_size = 0; + unsigned int count = this->float_data_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->float_data_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Datum::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.Datum) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const Datum* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.Datum) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.Datum) + UnsafeMergeFrom(*source); + } +} + +void Datum::MergeFrom(const Datum& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.Datum) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void Datum::UnsafeMergeFrom(const Datum& from) { + GOOGLE_DCHECK(&from != this); + float_data_.UnsafeMergeFrom(from.float_data_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_channels()) { + set_channels(from.channels()); + } + if (from.has_height()) { + set_height(from.height()); + } + if (from.has_width()) { + set_width(from.width()); + } + if (from.has_data()) { + set_has_data(); + data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.data_); + } + if (from.has_label()) { + set_label(from.label()); + } + if (from.has_encoded()) { + set_encoded(from.encoded()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void Datum::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.Datum) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Datum::CopyFrom(const Datum& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.Datum) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool Datum::IsInitialized() const { + + return true; +} + +void Datum::Swap(Datum* other) { + if (other == this) return; + InternalSwap(other); +} +void Datum::InternalSwap(Datum* other) { + std::swap(channels_, other->channels_); + std::swap(height_, other->height_); + std::swap(width_, other->width_); + data_.Swap(&other->data_); + std::swap(label_, other->label_); + float_data_.UnsafeArenaSwap(&other->float_data_); + std::swap(encoded_, other->encoded_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata Datum::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Datum_descriptor_; + metadata.reflection = Datum_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// Datum + +// optional int32 channels = 1; +bool Datum::has_channels() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void Datum::set_has_channels() { + _has_bits_[0] |= 0x00000001u; +} +void Datum::clear_has_channels() { + _has_bits_[0] &= ~0x00000001u; +} +void Datum::clear_channels() { + channels_ = 0; + clear_has_channels(); +} +::google::protobuf::int32 Datum::channels() const { + // @@protoc_insertion_point(field_get:caffe.Datum.channels) + return channels_; +} +void Datum::set_channels(::google::protobuf::int32 value) { + set_has_channels(); + channels_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.channels) +} + +// optional int32 height = 2; +bool Datum::has_height() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void Datum::set_has_height() { + _has_bits_[0] |= 0x00000002u; +} +void Datum::clear_has_height() { + _has_bits_[0] &= ~0x00000002u; +} +void Datum::clear_height() { + height_ = 0; + clear_has_height(); +} +::google::protobuf::int32 Datum::height() const { + // @@protoc_insertion_point(field_get:caffe.Datum.height) + return height_; +} +void Datum::set_height(::google::protobuf::int32 value) { + set_has_height(); + height_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.height) +} + +// optional int32 width = 3; +bool Datum::has_width() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void Datum::set_has_width() { + _has_bits_[0] |= 0x00000004u; +} +void Datum::clear_has_width() { + _has_bits_[0] &= ~0x00000004u; +} +void Datum::clear_width() { + width_ = 0; + clear_has_width(); +} +::google::protobuf::int32 Datum::width() const { + // @@protoc_insertion_point(field_get:caffe.Datum.width) + return width_; +} +void Datum::set_width(::google::protobuf::int32 value) { + set_has_width(); + width_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.width) +} + +// optional bytes data = 4; +bool Datum::has_data() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void Datum::set_has_data() { + _has_bits_[0] |= 0x00000008u; +} +void Datum::clear_has_data() { + _has_bits_[0] &= ~0x00000008u; +} +void Datum::clear_data() { + data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_data(); +} +const ::std::string& Datum::data() const { + // @@protoc_insertion_point(field_get:caffe.Datum.data) + return data_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void Datum::set_data(const ::std::string& value) { + set_has_data(); + data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.Datum.data) +} +void Datum::set_data(const char* value) { + set_has_data(); + data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.Datum.data) +} +void Datum::set_data(const void* value, size_t size) { + set_has_data(); + data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.Datum.data) +} +::std::string* Datum::mutable_data() { + set_has_data(); + // @@protoc_insertion_point(field_mutable:caffe.Datum.data) + return data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* Datum::release_data() { + // @@protoc_insertion_point(field_release:caffe.Datum.data) + clear_has_data(); + return data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void Datum::set_allocated_data(::std::string* data) { + if (data != NULL) { + set_has_data(); + } else { + clear_has_data(); + } + data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data); + // @@protoc_insertion_point(field_set_allocated:caffe.Datum.data) +} + +// optional int32 label = 5; +bool Datum::has_label() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void Datum::set_has_label() { + _has_bits_[0] |= 0x00000010u; +} +void Datum::clear_has_label() { + _has_bits_[0] &= ~0x00000010u; +} +void Datum::clear_label() { + label_ = 0; + clear_has_label(); +} +::google::protobuf::int32 Datum::label() const { + // @@protoc_insertion_point(field_get:caffe.Datum.label) + return label_; +} +void Datum::set_label(::google::protobuf::int32 value) { + set_has_label(); + label_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.label) +} + +// repeated float float_data = 6; +int Datum::float_data_size() const { + return float_data_.size(); +} +void Datum::clear_float_data() { + float_data_.Clear(); +} +float Datum::float_data(int index) const { + // @@protoc_insertion_point(field_get:caffe.Datum.float_data) + return float_data_.Get(index); +} +void Datum::set_float_data(int index, float value) { + float_data_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.Datum.float_data) +} +void Datum::add_float_data(float value) { + float_data_.Add(value); + // @@protoc_insertion_point(field_add:caffe.Datum.float_data) +} +const ::google::protobuf::RepeatedField< float >& +Datum::float_data() const { + // @@protoc_insertion_point(field_list:caffe.Datum.float_data) + return float_data_; +} +::google::protobuf::RepeatedField< float >* +Datum::mutable_float_data() { + // @@protoc_insertion_point(field_mutable_list:caffe.Datum.float_data) + return &float_data_; +} + +// optional bool encoded = 7 [default = false]; +bool Datum::has_encoded() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void Datum::set_has_encoded() { + _has_bits_[0] |= 0x00000040u; +} +void Datum::clear_has_encoded() { + _has_bits_[0] &= ~0x00000040u; +} +void Datum::clear_encoded() { + encoded_ = false; + clear_has_encoded(); +} +bool Datum::encoded() const { + // @@protoc_insertion_point(field_get:caffe.Datum.encoded) + return encoded_; +} +void Datum::set_encoded(bool value) { + set_has_encoded(); + encoded_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.encoded) +} + +inline const Datum* Datum::internal_default_instance() { + return &Datum_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* FillerParameter_VarianceNorm_descriptor() { + protobuf_AssignDescriptorsOnce(); + return FillerParameter_VarianceNorm_descriptor_; +} +bool FillerParameter_VarianceNorm_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const FillerParameter_VarianceNorm FillerParameter::FAN_IN; +const FillerParameter_VarianceNorm FillerParameter::FAN_OUT; +const FillerParameter_VarianceNorm FillerParameter::AVERAGE; +const FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MIN; +const FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MAX; +const int FillerParameter::VarianceNorm_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +::std::string* FillerParameter::_default_type_ = NULL; +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int FillerParameter::kTypeFieldNumber; +const int FillerParameter::kValueFieldNumber; +const int FillerParameter::kMinFieldNumber; +const int FillerParameter::kMaxFieldNumber; +const int FillerParameter::kMeanFieldNumber; +const int FillerParameter::kStdFieldNumber; +const int FillerParameter::kSparseFieldNumber; +const int FillerParameter::kVarianceNormFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +FillerParameter::FillerParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.FillerParameter) +} + +void FillerParameter::InitAsDefaultInstance() { +} + +FillerParameter::FillerParameter(const FillerParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.FillerParameter) +} + +void FillerParameter::SharedCtor() { + _cached_size_ = 0; + type_.UnsafeSetDefault(_default_type_); + ::memset(&value_, 0, reinterpret_cast(&variance_norm_) - + reinterpret_cast(&value_) + sizeof(variance_norm_)); + sparse_ = -1; + max_ = 1; + std_ = 1; +} + +FillerParameter::~FillerParameter() { + // @@protoc_insertion_point(destructor:caffe.FillerParameter) + SharedDtor(); +} + +void FillerParameter::SharedDtor() { + type_.DestroyNoArena(_default_type_); +} + +void FillerParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FillerParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FillerParameter_descriptor_; +} + +const FillerParameter& FillerParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed FillerParameter_default_instance_; + +FillerParameter* FillerParameter::New(::google::protobuf::Arena* arena) const { + FillerParameter* n = new FillerParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void FillerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.FillerParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(FillerParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 255u) { + ZR_(value_, variance_norm_); + if (has_type()) { + type_.ClearToDefaultNoArena(_default_type_); + } + max_ = 1; + std_ = 1; + sparse_ = -1; + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool FillerParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.FillerParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string type = 1 [default = "constant"]; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.FillerParameter.type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_value; + break; + } + + // optional float value = 2 [default = 0]; + case 2: { + if (tag == 21) { + parse_value: + set_has_value(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &value_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_min; + break; + } + + // optional float min = 3 [default = 0]; + case 3: { + if (tag == 29) { + parse_min: + set_has_min(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &min_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_max; + break; + } + + // optional float max = 4 [default = 1]; + case 4: { + if (tag == 37) { + parse_max: + set_has_max(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &max_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_mean; + break; + } + + // optional float mean = 5 [default = 0]; + case 5: { + if (tag == 45) { + parse_mean: + set_has_mean(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &mean_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(53)) goto parse_std; + break; + } + + // optional float std = 6 [default = 1]; + case 6: { + if (tag == 53) { + parse_std: + set_has_std(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &std_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_sparse; + break; + } + + // optional int32 sparse = 7 [default = -1]; + case 7: { + if (tag == 56) { + parse_sparse: + set_has_sparse(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &sparse_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_variance_norm; + break; + } + + // optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + case 8: { + if (tag == 64) { + parse_variance_norm: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::FillerParameter_VarianceNorm_IsValid(value)) { + set_variance_norm(static_cast< ::caffe::FillerParameter_VarianceNorm >(value)); + } else { + mutable_unknown_fields()->AddVarint(8, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.FillerParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.FillerParameter) + return false; +#undef DO_ +} + +void FillerParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.FillerParameter) + // optional string type = 1 [default = "constant"]; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.FillerParameter.type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->type(), output); + } + + // optional float value = 2 [default = 0]; + if (has_value()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->value(), output); + } + + // optional float min = 3 [default = 0]; + if (has_min()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->min(), output); + } + + // optional float max = 4 [default = 1]; + if (has_max()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->max(), output); + } + + // optional float mean = 5 [default = 0]; + if (has_mean()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->mean(), output); + } + + // optional float std = 6 [default = 1]; + if (has_std()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->std(), output); + } + + // optional int32 sparse = 7 [default = -1]; + if (has_sparse()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->sparse(), output); + } + + // optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + if (has_variance_norm()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 8, this->variance_norm(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.FillerParameter) +} + +::google::protobuf::uint8* FillerParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.FillerParameter) + // optional string type = 1 [default = "constant"]; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.FillerParameter.type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->type(), target); + } + + // optional float value = 2 [default = 0]; + if (has_value()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->value(), target); + } + + // optional float min = 3 [default = 0]; + if (has_min()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->min(), target); + } + + // optional float max = 4 [default = 1]; + if (has_max()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->max(), target); + } + + // optional float mean = 5 [default = 0]; + if (has_mean()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->mean(), target); + } + + // optional float std = 6 [default = 1]; + if (has_std()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->std(), target); + } + + // optional int32 sparse = 7 [default = -1]; + if (has_sparse()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->sparse(), target); + } + + // optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + if (has_variance_norm()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 8, this->variance_norm(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.FillerParameter) + return target; +} + +size_t FillerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.FillerParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional string type = 1 [default = "constant"]; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + // optional float value = 2 [default = 0]; + if (has_value()) { + total_size += 1 + 4; + } + + // optional float min = 3 [default = 0]; + if (has_min()) { + total_size += 1 + 4; + } + + // optional float max = 4 [default = 1]; + if (has_max()) { + total_size += 1 + 4; + } + + // optional float mean = 5 [default = 0]; + if (has_mean()) { + total_size += 1 + 4; + } + + // optional float std = 6 [default = 1]; + if (has_std()) { + total_size += 1 + 4; + } + + // optional int32 sparse = 7 [default = -1]; + if (has_sparse()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->sparse()); + } + + // optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + if (has_variance_norm()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->variance_norm()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FillerParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.FillerParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const FillerParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.FillerParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.FillerParameter) + UnsafeMergeFrom(*source); + } +} + +void FillerParameter::MergeFrom(const FillerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.FillerParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void FillerParameter::UnsafeMergeFrom(const FillerParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_type()) { + set_has_type(); + type_.AssignWithDefault(_default_type_, from.type_); + } + if (from.has_value()) { + set_value(from.value()); + } + if (from.has_min()) { + set_min(from.min()); + } + if (from.has_max()) { + set_max(from.max()); + } + if (from.has_mean()) { + set_mean(from.mean()); + } + if (from.has_std()) { + set_std(from.std()); + } + if (from.has_sparse()) { + set_sparse(from.sparse()); + } + if (from.has_variance_norm()) { + set_variance_norm(from.variance_norm()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void FillerParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.FillerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FillerParameter::CopyFrom(const FillerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.FillerParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool FillerParameter::IsInitialized() const { + + return true; +} + +void FillerParameter::Swap(FillerParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void FillerParameter::InternalSwap(FillerParameter* other) { + type_.Swap(&other->type_); + std::swap(value_, other->value_); + std::swap(min_, other->min_); + std::swap(max_, other->max_); + std::swap(mean_, other->mean_); + std::swap(std_, other->std_); + std::swap(sparse_, other->sparse_); + std::swap(variance_norm_, other->variance_norm_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata FillerParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FillerParameter_descriptor_; + metadata.reflection = FillerParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// FillerParameter + +// optional string type = 1 [default = "constant"]; +bool FillerParameter::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void FillerParameter::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +void FillerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +void FillerParameter::clear_type() { + type_.ClearToDefaultNoArena(_default_type_); + clear_has_type(); +} +const ::std::string& FillerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.type) + return type_.GetNoArena(_default_type_); +} +void FillerParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(_default_type_, value); + // @@protoc_insertion_point(field_set:caffe.FillerParameter.type) +} +void FillerParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(_default_type_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.FillerParameter.type) +} +void FillerParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(_default_type_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.FillerParameter.type) +} +::std::string* FillerParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.FillerParameter.type) + return type_.MutableNoArena(_default_type_); +} +::std::string* FillerParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.FillerParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(_default_type_); +} +void FillerParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(_default_type_, type); + // @@protoc_insertion_point(field_set_allocated:caffe.FillerParameter.type) +} + +// optional float value = 2 [default = 0]; +bool FillerParameter::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void FillerParameter::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +void FillerParameter::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +void FillerParameter::clear_value() { + value_ = 0; + clear_has_value(); +} +float FillerParameter::value() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.value) + return value_; +} +void FillerParameter::set_value(float value) { + set_has_value(); + value_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.value) +} + +// optional float min = 3 [default = 0]; +bool FillerParameter::has_min() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void FillerParameter::set_has_min() { + _has_bits_[0] |= 0x00000004u; +} +void FillerParameter::clear_has_min() { + _has_bits_[0] &= ~0x00000004u; +} +void FillerParameter::clear_min() { + min_ = 0; + clear_has_min(); +} +float FillerParameter::min() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.min) + return min_; +} +void FillerParameter::set_min(float value) { + set_has_min(); + min_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.min) +} + +// optional float max = 4 [default = 1]; +bool FillerParameter::has_max() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void FillerParameter::set_has_max() { + _has_bits_[0] |= 0x00000008u; +} +void FillerParameter::clear_has_max() { + _has_bits_[0] &= ~0x00000008u; +} +void FillerParameter::clear_max() { + max_ = 1; + clear_has_max(); +} +float FillerParameter::max() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.max) + return max_; +} +void FillerParameter::set_max(float value) { + set_has_max(); + max_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.max) +} + +// optional float mean = 5 [default = 0]; +bool FillerParameter::has_mean() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void FillerParameter::set_has_mean() { + _has_bits_[0] |= 0x00000010u; +} +void FillerParameter::clear_has_mean() { + _has_bits_[0] &= ~0x00000010u; +} +void FillerParameter::clear_mean() { + mean_ = 0; + clear_has_mean(); +} +float FillerParameter::mean() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.mean) + return mean_; +} +void FillerParameter::set_mean(float value) { + set_has_mean(); + mean_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.mean) +} + +// optional float std = 6 [default = 1]; +bool FillerParameter::has_std() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void FillerParameter::set_has_std() { + _has_bits_[0] |= 0x00000020u; +} +void FillerParameter::clear_has_std() { + _has_bits_[0] &= ~0x00000020u; +} +void FillerParameter::clear_std() { + std_ = 1; + clear_has_std(); +} +float FillerParameter::std() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.std) + return std_; +} +void FillerParameter::set_std(float value) { + set_has_std(); + std_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.std) +} + +// optional int32 sparse = 7 [default = -1]; +bool FillerParameter::has_sparse() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void FillerParameter::set_has_sparse() { + _has_bits_[0] |= 0x00000040u; +} +void FillerParameter::clear_has_sparse() { + _has_bits_[0] &= ~0x00000040u; +} +void FillerParameter::clear_sparse() { + sparse_ = -1; + clear_has_sparse(); +} +::google::protobuf::int32 FillerParameter::sparse() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.sparse) + return sparse_; +} +void FillerParameter::set_sparse(::google::protobuf::int32 value) { + set_has_sparse(); + sparse_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.sparse) +} + +// optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; +bool FillerParameter::has_variance_norm() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void FillerParameter::set_has_variance_norm() { + _has_bits_[0] |= 0x00000080u; +} +void FillerParameter::clear_has_variance_norm() { + _has_bits_[0] &= ~0x00000080u; +} +void FillerParameter::clear_variance_norm() { + variance_norm_ = 0; + clear_has_variance_norm(); +} +::caffe::FillerParameter_VarianceNorm FillerParameter::variance_norm() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.variance_norm) + return static_cast< ::caffe::FillerParameter_VarianceNorm >(variance_norm_); +} +void FillerParameter::set_variance_norm(::caffe::FillerParameter_VarianceNorm value) { + assert(::caffe::FillerParameter_VarianceNorm_IsValid(value)); + set_has_variance_norm(); + variance_norm_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.variance_norm) +} + +inline const FillerParameter* FillerParameter::internal_default_instance() { + return &FillerParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NetParameter::kNameFieldNumber; +const int NetParameter::kInputFieldNumber; +const int NetParameter::kInputShapeFieldNumber; +const int NetParameter::kInputDimFieldNumber; +const int NetParameter::kForceBackwardFieldNumber; +const int NetParameter::kStateFieldNumber; +const int NetParameter::kDebugInfoFieldNumber; +const int NetParameter::kLayerFieldNumber; +const int NetParameter::kLayersFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NetParameter::NetParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.NetParameter) +} + +void NetParameter::InitAsDefaultInstance() { + state_ = const_cast< ::caffe::NetState*>( + ::caffe::NetState::internal_default_instance()); +} + +NetParameter::NetParameter(const NetParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.NetParameter) +} + +void NetParameter::SharedCtor() { + _cached_size_ = 0; + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + state_ = NULL; + ::memset(&force_backward_, 0, reinterpret_cast(&debug_info_) - + reinterpret_cast(&force_backward_) + sizeof(debug_info_)); +} + +NetParameter::~NetParameter() { + // @@protoc_insertion_point(destructor:caffe.NetParameter) + SharedDtor(); +} + +void NetParameter::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != &NetParameter_default_instance_.get()) { + delete state_; + } +} + +void NetParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NetParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NetParameter_descriptor_; +} + +const NetParameter& NetParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NetParameter_default_instance_; + +NetParameter* NetParameter::New(::google::protobuf::Arena* arena) const { + NetParameter* n = new NetParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void NetParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.NetParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(NetParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 113u) { + ZR_(force_backward_, debug_info_); + if (has_name()) { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_state()) { + if (state_ != NULL) state_->::caffe::NetState::Clear(); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + input_.Clear(); + input_shape_.Clear(); + input_dim_.Clear(); + layer_.Clear(); + layers_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool NetParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.NetParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.NetParameter.name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_layers; + break; + } + + // repeated .caffe.V1LayerParameter layers = 2; + case 2: { + if (tag == 18) { + parse_layers: + DO_(input->IncrementRecursionDepth()); + parse_loop_layers: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_layers())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_loop_layers; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(26)) goto parse_input; + break; + } + + // repeated string input = 3; + case 3: { + if (tag == 26) { + parse_input: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_input())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->input(this->input_size() - 1).data(), + this->input(this->input_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.NetParameter.input"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_input; + if (input->ExpectTag(32)) goto parse_input_dim; + break; + } + + // repeated int32 input_dim = 4; + case 4: { + if (tag == 32) { + parse_input_dim: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 32, input, this->mutable_input_dim()))); + } else if (tag == 34) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_input_dim()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_input_dim; + if (input->ExpectTag(40)) goto parse_force_backward; + break; + } + + // optional bool force_backward = 5 [default = false]; + case 5: { + if (tag == 40) { + parse_force_backward: + set_has_force_backward(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &force_backward_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_state; + break; + } + + // optional .caffe.NetState state = 6; + case 6: { + if (tag == 50) { + parse_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_debug_info; + break; + } + + // optional bool debug_info = 7 [default = false]; + case 7: { + if (tag == 56) { + parse_debug_info: + set_has_debug_info(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &debug_info_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_input_shape; + break; + } + + // repeated .caffe.BlobShape input_shape = 8; + case 8: { + if (tag == 66) { + parse_input_shape: + DO_(input->IncrementRecursionDepth()); + parse_loop_input_shape: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_input_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_loop_input_shape; + if (input->ExpectTag(802)) goto parse_loop_layer; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .caffe.LayerParameter layer = 100; + case 100: { + if (tag == 802) { + DO_(input->IncrementRecursionDepth()); + parse_loop_layer: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_layer())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(802)) goto parse_loop_layer; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.NetParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.NetParameter) + return false; +#undef DO_ +} + +void NetParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.NetParameter) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetParameter.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // repeated .caffe.V1LayerParameter layers = 2; + for (unsigned int i = 0, n = this->layers_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->layers(i), output); + } + + // repeated string input = 3; + for (int i = 0; i < this->input_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->input(i).data(), this->input(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetParameter.input"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->input(i), output); + } + + // repeated int32 input_dim = 4; + for (int i = 0; i < this->input_dim_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32( + 4, this->input_dim(i), output); + } + + // optional bool force_backward = 5 [default = false]; + if (has_force_backward()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->force_backward(), output); + } + + // optional .caffe.NetState state = 6; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, *this->state_, output); + } + + // optional bool debug_info = 7 [default = false]; + if (has_debug_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->debug_info(), output); + } + + // repeated .caffe.BlobShape input_shape = 8; + for (unsigned int i = 0, n = this->input_shape_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->input_shape(i), output); + } + + // repeated .caffe.LayerParameter layer = 100; + for (unsigned int i = 0, n = this->layer_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 100, this->layer(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.NetParameter) +} + +::google::protobuf::uint8* NetParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.NetParameter) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetParameter.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // repeated .caffe.V1LayerParameter layers = 2; + for (unsigned int i = 0, n = this->layers_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, this->layers(i), false, target); + } + + // repeated string input = 3; + for (int i = 0; i < this->input_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->input(i).data(), this->input(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetParameter.input"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->input(i), target); + } + + // repeated int32 input_dim = 4; + for (int i = 0; i < this->input_dim_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArray(4, this->input_dim(i), target); + } + + // optional bool force_backward = 5 [default = false]; + if (has_force_backward()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->force_backward(), target); + } + + // optional .caffe.NetState state = 6; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 6, *this->state_, false, target); + } + + // optional bool debug_info = 7 [default = false]; + if (has_debug_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->debug_info(), target); + } + + // repeated .caffe.BlobShape input_shape = 8; + for (unsigned int i = 0, n = this->input_shape_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 8, this->input_shape(i), false, target); + } + + // repeated .caffe.LayerParameter layer = 100; + for (unsigned int i = 0, n = this->layer_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 100, this->layer(i), false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.NetParameter) + return target; +} + +size_t NetParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.NetParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 113u) { + // optional string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional bool force_backward = 5 [default = false]; + if (has_force_backward()) { + total_size += 1 + 1; + } + + // optional .caffe.NetState state = 6; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->state_); + } + + // optional bool debug_info = 7 [default = false]; + if (has_debug_info()) { + total_size += 1 + 1; + } + + } + // repeated string input = 3; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->input_size()); + for (int i = 0; i < this->input_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->input(i)); + } + + // repeated .caffe.BlobShape input_shape = 8; + { + unsigned int count = this->input_shape_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->input_shape(i)); + } + } + + // repeated int32 input_dim = 4; + { + size_t data_size = 0; + unsigned int count = this->input_dim_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->input_dim(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->input_dim_size()); + total_size += data_size; + } + + // repeated .caffe.LayerParameter layer = 100; + { + unsigned int count = this->layer_size(); + total_size += 2UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->layer(i)); + } + } + + // repeated .caffe.V1LayerParameter layers = 2; + { + unsigned int count = this->layers_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->layers(i)); + } + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NetParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.NetParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NetParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.NetParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.NetParameter) + UnsafeMergeFrom(*source); + } +} + +void NetParameter::MergeFrom(const NetParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.NetParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NetParameter::UnsafeMergeFrom(const NetParameter& from) { + GOOGLE_DCHECK(&from != this); + input_.UnsafeMergeFrom(from.input_); + input_shape_.MergeFrom(from.input_shape_); + input_dim_.UnsafeMergeFrom(from.input_dim_); + layer_.MergeFrom(from.layer_); + layers_.MergeFrom(from.layers_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_force_backward()) { + set_force_backward(from.force_backward()); + } + if (from.has_state()) { + mutable_state()->::caffe::NetState::MergeFrom(from.state()); + } + if (from.has_debug_info()) { + set_debug_info(from.debug_info()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void NetParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.NetParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NetParameter::CopyFrom(const NetParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.NetParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NetParameter::IsInitialized() const { + + return true; +} + +void NetParameter::Swap(NetParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void NetParameter::InternalSwap(NetParameter* other) { + name_.Swap(&other->name_); + input_.UnsafeArenaSwap(&other->input_); + input_shape_.UnsafeArenaSwap(&other->input_shape_); + input_dim_.UnsafeArenaSwap(&other->input_dim_); + std::swap(force_backward_, other->force_backward_); + std::swap(state_, other->state_); + std::swap(debug_info_, other->debug_info_); + layer_.UnsafeArenaSwap(&other->layer_); + layers_.UnsafeArenaSwap(&other->layers_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NetParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NetParameter_descriptor_; + metadata.reflection = NetParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NetParameter + +// optional string name = 1; +bool NetParameter::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void NetParameter::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +void NetParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +void NetParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +const ::std::string& NetParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void NetParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.NetParameter.name) +} +void NetParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.NetParameter.name) +} +void NetParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.NetParameter.name) +} +::std::string* NetParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* NetParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.NetParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void NetParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.NetParameter.name) +} + +// repeated string input = 3; +int NetParameter::input_size() const { + return input_.size(); +} +void NetParameter::clear_input() { + input_.Clear(); +} +const ::std::string& NetParameter::input(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.input) + return input_.Get(index); +} +::std::string* NetParameter::mutable_input(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.input) + return input_.Mutable(index); +} +void NetParameter::set_input(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetParameter.input) + input_.Mutable(index)->assign(value); +} +void NetParameter::set_input(int index, const char* value) { + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetParameter.input) +} +void NetParameter::set_input(int index, const char* value, size_t size) { + input_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetParameter.input) +} +::std::string* NetParameter::add_input() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetParameter.input) + return input_.Add(); +} +void NetParameter::add_input(const ::std::string& value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetParameter.input) +} +void NetParameter::add_input(const char* value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetParameter.input) +} +void NetParameter::add_input(const char* value, size_t size) { + input_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetParameter.input) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetParameter::input() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.input) + return input_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +NetParameter::mutable_input() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input) + return &input_; +} + +// repeated .caffe.BlobShape input_shape = 8; +int NetParameter::input_shape_size() const { + return input_shape_.size(); +} +void NetParameter::clear_input_shape() { + input_shape_.Clear(); +} +const ::caffe::BlobShape& NetParameter::input_shape(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.input_shape) + return input_shape_.Get(index); +} +::caffe::BlobShape* NetParameter::mutable_input_shape(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.input_shape) + return input_shape_.Mutable(index); +} +::caffe::BlobShape* NetParameter::add_input_shape() { + // @@protoc_insertion_point(field_add:caffe.NetParameter.input_shape) + return input_shape_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* +NetParameter::mutable_input_shape() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input_shape) + return &input_shape_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& +NetParameter::input_shape() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.input_shape) + return input_shape_; +} + +// repeated int32 input_dim = 4; +int NetParameter::input_dim_size() const { + return input_dim_.size(); +} +void NetParameter::clear_input_dim() { + input_dim_.Clear(); +} +::google::protobuf::int32 NetParameter::input_dim(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.input_dim) + return input_dim_.Get(index); +} +void NetParameter::set_input_dim(int index, ::google::protobuf::int32 value) { + input_dim_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.NetParameter.input_dim) +} +void NetParameter::add_input_dim(::google::protobuf::int32 value) { + input_dim_.Add(value); + // @@protoc_insertion_point(field_add:caffe.NetParameter.input_dim) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +NetParameter::input_dim() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.input_dim) + return input_dim_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +NetParameter::mutable_input_dim() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input_dim) + return &input_dim_; +} + +// optional bool force_backward = 5 [default = false]; +bool NetParameter::has_force_backward() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void NetParameter::set_has_force_backward() { + _has_bits_[0] |= 0x00000010u; +} +void NetParameter::clear_has_force_backward() { + _has_bits_[0] &= ~0x00000010u; +} +void NetParameter::clear_force_backward() { + force_backward_ = false; + clear_has_force_backward(); +} +bool NetParameter::force_backward() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.force_backward) + return force_backward_; +} +void NetParameter::set_force_backward(bool value) { + set_has_force_backward(); + force_backward_ = value; + // @@protoc_insertion_point(field_set:caffe.NetParameter.force_backward) +} + +// optional .caffe.NetState state = 6; +bool NetParameter::has_state() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void NetParameter::set_has_state() { + _has_bits_[0] |= 0x00000020u; +} +void NetParameter::clear_has_state() { + _has_bits_[0] &= ~0x00000020u; +} +void NetParameter::clear_state() { + if (state_ != NULL) state_->::caffe::NetState::Clear(); + clear_has_state(); +} +const ::caffe::NetState& NetParameter::state() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.state) + return state_ != NULL ? *state_ + : *::caffe::NetState::internal_default_instance(); +} +::caffe::NetState* NetParameter::mutable_state() { + set_has_state(); + if (state_ == NULL) { + state_ = new ::caffe::NetState; + } + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.state) + return state_; +} +::caffe::NetState* NetParameter::release_state() { + // @@protoc_insertion_point(field_release:caffe.NetParameter.state) + clear_has_state(); + ::caffe::NetState* temp = state_; + state_ = NULL; + return temp; +} +void NetParameter::set_allocated_state(::caffe::NetState* state) { + delete state_; + state_ = state; + if (state) { + set_has_state(); + } else { + clear_has_state(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.NetParameter.state) +} + +// optional bool debug_info = 7 [default = false]; +bool NetParameter::has_debug_info() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void NetParameter::set_has_debug_info() { + _has_bits_[0] |= 0x00000040u; +} +void NetParameter::clear_has_debug_info() { + _has_bits_[0] &= ~0x00000040u; +} +void NetParameter::clear_debug_info() { + debug_info_ = false; + clear_has_debug_info(); +} +bool NetParameter::debug_info() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.debug_info) + return debug_info_; +} +void NetParameter::set_debug_info(bool value) { + set_has_debug_info(); + debug_info_ = value; + // @@protoc_insertion_point(field_set:caffe.NetParameter.debug_info) +} + +// repeated .caffe.LayerParameter layer = 100; +int NetParameter::layer_size() const { + return layer_.size(); +} +void NetParameter::clear_layer() { + layer_.Clear(); +} +const ::caffe::LayerParameter& NetParameter::layer(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.layer) + return layer_.Get(index); +} +::caffe::LayerParameter* NetParameter::mutable_layer(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.layer) + return layer_.Mutable(index); +} +::caffe::LayerParameter* NetParameter::add_layer() { + // @@protoc_insertion_point(field_add:caffe.NetParameter.layer) + return layer_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >* +NetParameter::mutable_layer() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.layer) + return &layer_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >& +NetParameter::layer() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.layer) + return layer_; +} + +// repeated .caffe.V1LayerParameter layers = 2; +int NetParameter::layers_size() const { + return layers_.size(); +} +void NetParameter::clear_layers() { + layers_.Clear(); +} +const ::caffe::V1LayerParameter& NetParameter::layers(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.layers) + return layers_.Get(index); +} +::caffe::V1LayerParameter* NetParameter::mutable_layers(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.layers) + return layers_.Mutable(index); +} +::caffe::V1LayerParameter* NetParameter::add_layers() { + // @@protoc_insertion_point(field_add:caffe.NetParameter.layers) + return layers_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::V1LayerParameter >* +NetParameter::mutable_layers() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.layers) + return &layers_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::V1LayerParameter >& +NetParameter::layers() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.layers) + return layers_; +} + +inline const NetParameter* NetParameter::internal_default_instance() { + return &NetParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SolverParameter_SnapshotFormat_descriptor_; +} +bool SolverParameter_SnapshotFormat_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const SolverParameter_SnapshotFormat SolverParameter::HDF5; +const SolverParameter_SnapshotFormat SolverParameter::BINARYPROTO; +const SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MIN; +const SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MAX; +const int SolverParameter::SnapshotFormat_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* SolverParameter_SolverMode_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SolverParameter_SolverMode_descriptor_; +} +bool SolverParameter_SolverMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const SolverParameter_SolverMode SolverParameter::CPU; +const SolverParameter_SolverMode SolverParameter::GPU; +const SolverParameter_SolverMode SolverParameter::SolverMode_MIN; +const SolverParameter_SolverMode SolverParameter::SolverMode_MAX; +const int SolverParameter::SolverMode_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* SolverParameter_SolverType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SolverParameter_SolverType_descriptor_; +} +bool SolverParameter_SolverType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const SolverParameter_SolverType SolverParameter::SGD; +const SolverParameter_SolverType SolverParameter::NESTEROV; +const SolverParameter_SolverType SolverParameter::ADAGRAD; +const SolverParameter_SolverType SolverParameter::RMSPROP; +const SolverParameter_SolverType SolverParameter::ADADELTA; +const SolverParameter_SolverType SolverParameter::ADAM; +const SolverParameter_SolverType SolverParameter::SolverType_MIN; +const SolverParameter_SolverType SolverParameter::SolverType_MAX; +const int SolverParameter::SolverType_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +::std::string* SolverParameter::_default_regularization_type_ = NULL; +::std::string* SolverParameter::_default_type_ = NULL; +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int SolverParameter::kNetFieldNumber; +const int SolverParameter::kNetParamFieldNumber; +const int SolverParameter::kTrainNetFieldNumber; +const int SolverParameter::kTestNetFieldNumber; +const int SolverParameter::kTrainNetParamFieldNumber; +const int SolverParameter::kTestNetParamFieldNumber; +const int SolverParameter::kTrainStateFieldNumber; +const int SolverParameter::kTestStateFieldNumber; +const int SolverParameter::kTestIterFieldNumber; +const int SolverParameter::kTestIntervalFieldNumber; +const int SolverParameter::kTestComputeLossFieldNumber; +const int SolverParameter::kTestInitializationFieldNumber; +const int SolverParameter::kBaseLrFieldNumber; +const int SolverParameter::kDisplayFieldNumber; +const int SolverParameter::kAverageLossFieldNumber; +const int SolverParameter::kMaxIterFieldNumber; +const int SolverParameter::kIterSizeFieldNumber; +const int SolverParameter::kLrPolicyFieldNumber; +const int SolverParameter::kGammaFieldNumber; +const int SolverParameter::kPowerFieldNumber; +const int SolverParameter::kMomentumFieldNumber; +const int SolverParameter::kWeightDecayFieldNumber; +const int SolverParameter::kRegularizationTypeFieldNumber; +const int SolverParameter::kStepsizeFieldNumber; +const int SolverParameter::kStepvalueFieldNumber; +const int SolverParameter::kClipGradientsFieldNumber; +const int SolverParameter::kSnapshotFieldNumber; +const int SolverParameter::kSnapshotPrefixFieldNumber; +const int SolverParameter::kSnapshotDiffFieldNumber; +const int SolverParameter::kSnapshotFormatFieldNumber; +const int SolverParameter::kSolverModeFieldNumber; +const int SolverParameter::kDeviceIdFieldNumber; +const int SolverParameter::kRandomSeedFieldNumber; +const int SolverParameter::kTypeFieldNumber; +const int SolverParameter::kDeltaFieldNumber; +const int SolverParameter::kMomentum2FieldNumber; +const int SolverParameter::kRmsDecayFieldNumber; +const int SolverParameter::kDebugInfoFieldNumber; +const int SolverParameter::kSnapshotAfterTrainFieldNumber; +const int SolverParameter::kSolverTypeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +SolverParameter::SolverParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.SolverParameter) +} + +void SolverParameter::InitAsDefaultInstance() { + net_param_ = const_cast< ::caffe::NetParameter*>( + ::caffe::NetParameter::internal_default_instance()); + train_net_param_ = const_cast< ::caffe::NetParameter*>( + ::caffe::NetParameter::internal_default_instance()); + train_state_ = const_cast< ::caffe::NetState*>( + ::caffe::NetState::internal_default_instance()); +} + +SolverParameter::SolverParameter(const SolverParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.SolverParameter) +} + +void SolverParameter::SharedCtor() { + net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + train_net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + lr_policy_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + regularization_type_.UnsafeSetDefault(_default_regularization_type_); + snapshot_prefix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_.UnsafeSetDefault(_default_type_); + net_param_ = NULL; + train_net_param_ = NULL; + train_state_ = NULL; + ::memset(&test_interval_, 0, reinterpret_cast(&solver_type_) - + reinterpret_cast(&test_interval_) + sizeof(solver_type_)); + rms_decay_ = 0.99f; + average_loss_ = 1; + iter_size_ = 1; + test_initialization_ = true; + snapshot_after_train_ = true; + clip_gradients_ = -1; + snapshot_format_ = 1; + solver_mode_ = 1; + random_seed_ = GOOGLE_LONGLONG(-1); + delta_ = 1e-08f; + momentum2_ = 0.999f; + _cached_size_ = 0; +} + +SolverParameter::~SolverParameter() { + // @@protoc_insertion_point(destructor:caffe.SolverParameter) + SharedDtor(); +} + +void SolverParameter::SharedDtor() { + net_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + train_net_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + lr_policy_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + regularization_type_.DestroyNoArena(_default_regularization_type_); + snapshot_prefix_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_.DestroyNoArena(_default_type_); + if (this != &SolverParameter_default_instance_.get()) { + delete net_param_; + delete train_net_param_; + delete train_state_; + } +} + +void SolverParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SolverParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SolverParameter_descriptor_; +} + +const SolverParameter& SolverParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed SolverParameter_default_instance_; + +SolverParameter* SolverParameter::New(::google::protobuf::Arena* arena) const { + SolverParameter* n = new SolverParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void SolverParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.SolverParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(SolverParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 87u) { + if (has_net()) { + net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_net_param()) { + if (net_param_ != NULL) net_param_->::caffe::NetParameter::Clear(); + } + if (has_train_net()) { + train_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_train_net_param()) { + if (train_net_param_ != NULL) train_net_param_->::caffe::NetParameter::Clear(); + } + if (has_train_state()) { + if (train_state_ != NULL) train_state_->::caffe::NetState::Clear(); + } + } + if (_has_bits_[8 / 32] & 65024u) { + ZR_(test_interval_, max_iter_); + test_compute_loss_ = false; + test_initialization_ = true; + average_loss_ = 1; + } + if (_has_bits_[16 / 32] & 16711680u) { + ZR_(gamma_, stepsize_); + iter_size_ = 1; + if (has_lr_policy()) { + lr_policy_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_regularization_type()) { + regularization_type_.ClearToDefaultNoArena(_default_regularization_type_); + } + } + if (_has_bits_[24 / 32] & 4261412864u) { + ZR_(snapshot_, device_id_); + clip_gradients_ = -1; + if (has_snapshot_prefix()) { + snapshot_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + snapshot_diff_ = false; + snapshot_format_ = 1; + solver_mode_ = 1; + } + if (_has_bits_[32 / 32] & 255u) { + random_seed_ = GOOGLE_LONGLONG(-1); + if (has_type()) { + type_.ClearToDefaultNoArena(_default_type_); + } + delta_ = 1e-08f; + momentum2_ = 0.999f; + rms_decay_ = 0.99f; + debug_info_ = false; + snapshot_after_train_ = true; + solver_type_ = 0; + } + +#undef ZR_HELPER_ +#undef ZR_ + + test_net_.Clear(); + test_net_param_.Clear(); + test_state_.Clear(); + test_iter_.Clear(); + stepvalue_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool SolverParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.SolverParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string train_net = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_train_net())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->train_net().data(), this->train_net().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverParameter.train_net"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_test_net; + break; + } + + // repeated string test_net = 2; + case 2: { + if (tag == 18) { + parse_test_net: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_test_net())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->test_net(this->test_net_size() - 1).data(), + this->test_net(this->test_net_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverParameter.test_net"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_test_net; + if (input->ExpectTag(24)) goto parse_test_iter; + break; + } + + // repeated int32 test_iter = 3; + case 3: { + if (tag == 24) { + parse_test_iter: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 24, input, this->mutable_test_iter()))); + } else if (tag == 26) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_test_iter()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_test_iter; + if (input->ExpectTag(32)) goto parse_test_interval; + break; + } + + // optional int32 test_interval = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_test_interval: + set_has_test_interval(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &test_interval_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_base_lr; + break; + } + + // optional float base_lr = 5; + case 5: { + if (tag == 45) { + parse_base_lr: + set_has_base_lr(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &base_lr_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_display; + break; + } + + // optional int32 display = 6; + case 6: { + if (tag == 48) { + parse_display: + set_has_display(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &display_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_max_iter; + break; + } + + // optional int32 max_iter = 7; + case 7: { + if (tag == 56) { + parse_max_iter: + set_has_max_iter(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &max_iter_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_lr_policy; + break; + } + + // optional string lr_policy = 8; + case 8: { + if (tag == 66) { + parse_lr_policy: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_lr_policy())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->lr_policy().data(), this->lr_policy().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverParameter.lr_policy"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(77)) goto parse_gamma; + break; + } + + // optional float gamma = 9; + case 9: { + if (tag == 77) { + parse_gamma: + set_has_gamma(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &gamma_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(85)) goto parse_power; + break; + } + + // optional float power = 10; + case 10: { + if (tag == 85) { + parse_power: + set_has_power(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &power_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(93)) goto parse_momentum; + break; + } + + // optional float momentum = 11; + case 11: { + if (tag == 93) { + parse_momentum: + set_has_momentum(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &momentum_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(101)) goto parse_weight_decay; + break; + } + + // optional float weight_decay = 12; + case 12: { + if (tag == 101) { + parse_weight_decay: + set_has_weight_decay(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &weight_decay_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(104)) goto parse_stepsize; + break; + } + + // optional int32 stepsize = 13; + case 13: { + if (tag == 104) { + parse_stepsize: + set_has_stepsize(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &stepsize_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(112)) goto parse_snapshot; + break; + } + + // optional int32 snapshot = 14 [default = 0]; + case 14: { + if (tag == 112) { + parse_snapshot: + set_has_snapshot(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &snapshot_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(122)) goto parse_snapshot_prefix; + break; + } + + // optional string snapshot_prefix = 15; + case 15: { + if (tag == 122) { + parse_snapshot_prefix: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_snapshot_prefix())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->snapshot_prefix().data(), this->snapshot_prefix().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverParameter.snapshot_prefix"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(128)) goto parse_snapshot_diff; + break; + } + + // optional bool snapshot_diff = 16 [default = false]; + case 16: { + if (tag == 128) { + parse_snapshot_diff: + set_has_snapshot_diff(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &snapshot_diff_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(136)) goto parse_solver_mode; + break; + } + + // optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + case 17: { + if (tag == 136) { + parse_solver_mode: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::SolverParameter_SolverMode_IsValid(value)) { + set_solver_mode(static_cast< ::caffe::SolverParameter_SolverMode >(value)); + } else { + mutable_unknown_fields()->AddVarint(17, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(144)) goto parse_device_id; + break; + } + + // optional int32 device_id = 18 [default = 0]; + case 18: { + if (tag == 144) { + parse_device_id: + set_has_device_id(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &device_id_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(152)) goto parse_test_compute_loss; + break; + } + + // optional bool test_compute_loss = 19 [default = false]; + case 19: { + if (tag == 152) { + parse_test_compute_loss: + set_has_test_compute_loss(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &test_compute_loss_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(160)) goto parse_random_seed; + break; + } + + // optional int64 random_seed = 20 [default = -1]; + case 20: { + if (tag == 160) { + parse_random_seed: + set_has_random_seed(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &random_seed_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(170)) goto parse_train_net_param; + break; + } + + // optional .caffe.NetParameter train_net_param = 21; + case 21: { + if (tag == 170) { + parse_train_net_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_train_net_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(178)) goto parse_test_net_param; + break; + } + + // repeated .caffe.NetParameter test_net_param = 22; + case 22: { + if (tag == 178) { + parse_test_net_param: + DO_(input->IncrementRecursionDepth()); + parse_loop_test_net_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_test_net_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(178)) goto parse_loop_test_net_param; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(184)) goto parse_debug_info; + break; + } + + // optional bool debug_info = 23 [default = false]; + case 23: { + if (tag == 184) { + parse_debug_info: + set_has_debug_info(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &debug_info_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(194)) goto parse_net; + break; + } + + // optional string net = 24; + case 24: { + if (tag == 194) { + parse_net: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_net())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->net().data(), this->net().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverParameter.net"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(202)) goto parse_net_param; + break; + } + + // optional .caffe.NetParameter net_param = 25; + case 25: { + if (tag == 202) { + parse_net_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_net_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(210)) goto parse_train_state; + break; + } + + // optional .caffe.NetState train_state = 26; + case 26: { + if (tag == 210) { + parse_train_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_train_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(218)) goto parse_test_state; + break; + } + + // repeated .caffe.NetState test_state = 27; + case 27: { + if (tag == 218) { + parse_test_state: + DO_(input->IncrementRecursionDepth()); + parse_loop_test_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_test_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(218)) goto parse_loop_test_state; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(224)) goto parse_snapshot_after_train; + break; + } + + // optional bool snapshot_after_train = 28 [default = true]; + case 28: { + if (tag == 224) { + parse_snapshot_after_train: + set_has_snapshot_after_train(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &snapshot_after_train_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(234)) goto parse_regularization_type; + break; + } + + // optional string regularization_type = 29 [default = "L2"]; + case 29: { + if (tag == 234) { + parse_regularization_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_regularization_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->regularization_type().data(), this->regularization_type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverParameter.regularization_type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(240)) goto parse_solver_type; + break; + } + + // optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + case 30: { + if (tag == 240) { + parse_solver_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::SolverParameter_SolverType_IsValid(value)) { + set_solver_type(static_cast< ::caffe::SolverParameter_SolverType >(value)); + } else { + mutable_unknown_fields()->AddVarint(30, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(253)) goto parse_delta; + break; + } + + // optional float delta = 31 [default = 1e-08]; + case 31: { + if (tag == 253) { + parse_delta: + set_has_delta(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &delta_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(256)) goto parse_test_initialization; + break; + } + + // optional bool test_initialization = 32 [default = true]; + case 32: { + if (tag == 256) { + parse_test_initialization: + set_has_test_initialization(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &test_initialization_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(264)) goto parse_average_loss; + break; + } + + // optional int32 average_loss = 33 [default = 1]; + case 33: { + if (tag == 264) { + parse_average_loss: + set_has_average_loss(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &average_loss_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(272)) goto parse_stepvalue; + break; + } + + // repeated int32 stepvalue = 34; + case 34: { + if (tag == 272) { + parse_stepvalue: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 2, 272, input, this->mutable_stepvalue()))); + } else if (tag == 274) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_stepvalue()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(272)) goto parse_stepvalue; + if (input->ExpectTag(285)) goto parse_clip_gradients; + break; + } + + // optional float clip_gradients = 35 [default = -1]; + case 35: { + if (tag == 285) { + parse_clip_gradients: + set_has_clip_gradients(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &clip_gradients_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(288)) goto parse_iter_size; + break; + } + + // optional int32 iter_size = 36 [default = 1]; + case 36: { + if (tag == 288) { + parse_iter_size: + set_has_iter_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &iter_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(296)) goto parse_snapshot_format; + break; + } + + // optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + case 37: { + if (tag == 296) { + parse_snapshot_format: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::SolverParameter_SnapshotFormat_IsValid(value)) { + set_snapshot_format(static_cast< ::caffe::SolverParameter_SnapshotFormat >(value)); + } else { + mutable_unknown_fields()->AddVarint(37, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(309)) goto parse_rms_decay; + break; + } + + // optional float rms_decay = 38 [default = 0.99]; + case 38: { + if (tag == 309) { + parse_rms_decay: + set_has_rms_decay(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &rms_decay_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(317)) goto parse_momentum2; + break; + } + + // optional float momentum2 = 39 [default = 0.999]; + case 39: { + if (tag == 317) { + parse_momentum2: + set_has_momentum2(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &momentum2_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(322)) goto parse_type; + break; + } + + // optional string type = 40 [default = "SGD"]; + case 40: { + if (tag == 322) { + parse_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverParameter.type"); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.SolverParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.SolverParameter) + return false; +#undef DO_ +} + +void SolverParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.SolverParameter) + // optional string train_net = 1; + if (has_train_net()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->train_net().data(), this->train_net().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.train_net"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->train_net(), output); + } + + // repeated string test_net = 2; + for (int i = 0; i < this->test_net_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->test_net(i).data(), this->test_net(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.test_net"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->test_net(i), output); + } + + // repeated int32 test_iter = 3; + for (int i = 0; i < this->test_iter_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32( + 3, this->test_iter(i), output); + } + + // optional int32 test_interval = 4 [default = 0]; + if (has_test_interval()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->test_interval(), output); + } + + // optional float base_lr = 5; + if (has_base_lr()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->base_lr(), output); + } + + // optional int32 display = 6; + if (has_display()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->display(), output); + } + + // optional int32 max_iter = 7; + if (has_max_iter()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->max_iter(), output); + } + + // optional string lr_policy = 8; + if (has_lr_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->lr_policy().data(), this->lr_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.lr_policy"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->lr_policy(), output); + } + + // optional float gamma = 9; + if (has_gamma()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->gamma(), output); + } + + // optional float power = 10; + if (has_power()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->power(), output); + } + + // optional float momentum = 11; + if (has_momentum()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->momentum(), output); + } + + // optional float weight_decay = 12; + if (has_weight_decay()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->weight_decay(), output); + } + + // optional int32 stepsize = 13; + if (has_stepsize()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->stepsize(), output); + } + + // optional int32 snapshot = 14 [default = 0]; + if (has_snapshot()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->snapshot(), output); + } + + // optional string snapshot_prefix = 15; + if (has_snapshot_prefix()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->snapshot_prefix().data(), this->snapshot_prefix().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.snapshot_prefix"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 15, this->snapshot_prefix(), output); + } + + // optional bool snapshot_diff = 16 [default = false]; + if (has_snapshot_diff()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->snapshot_diff(), output); + } + + // optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + if (has_solver_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 17, this->solver_mode(), output); + } + + // optional int32 device_id = 18 [default = 0]; + if (has_device_id()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(18, this->device_id(), output); + } + + // optional bool test_compute_loss = 19 [default = false]; + if (has_test_compute_loss()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(19, this->test_compute_loss(), output); + } + + // optional int64 random_seed = 20 [default = -1]; + if (has_random_seed()) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(20, this->random_seed(), output); + } + + // optional .caffe.NetParameter train_net_param = 21; + if (has_train_net_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 21, *this->train_net_param_, output); + } + + // repeated .caffe.NetParameter test_net_param = 22; + for (unsigned int i = 0, n = this->test_net_param_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 22, this->test_net_param(i), output); + } + + // optional bool debug_info = 23 [default = false]; + if (has_debug_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(23, this->debug_info(), output); + } + + // optional string net = 24; + if (has_net()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->net().data(), this->net().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.net"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 24, this->net(), output); + } + + // optional .caffe.NetParameter net_param = 25; + if (has_net_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 25, *this->net_param_, output); + } + + // optional .caffe.NetState train_state = 26; + if (has_train_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 26, *this->train_state_, output); + } + + // repeated .caffe.NetState test_state = 27; + for (unsigned int i = 0, n = this->test_state_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 27, this->test_state(i), output); + } + + // optional bool snapshot_after_train = 28 [default = true]; + if (has_snapshot_after_train()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(28, this->snapshot_after_train(), output); + } + + // optional string regularization_type = 29 [default = "L2"]; + if (has_regularization_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->regularization_type().data(), this->regularization_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.regularization_type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 29, this->regularization_type(), output); + } + + // optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + if (has_solver_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 30, this->solver_type(), output); + } + + // optional float delta = 31 [default = 1e-08]; + if (has_delta()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(31, this->delta(), output); + } + + // optional bool test_initialization = 32 [default = true]; + if (has_test_initialization()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(32, this->test_initialization(), output); + } + + // optional int32 average_loss = 33 [default = 1]; + if (has_average_loss()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(33, this->average_loss(), output); + } + + // repeated int32 stepvalue = 34; + for (int i = 0; i < this->stepvalue_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32( + 34, this->stepvalue(i), output); + } + + // optional float clip_gradients = 35 [default = -1]; + if (has_clip_gradients()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(35, this->clip_gradients(), output); + } + + // optional int32 iter_size = 36 [default = 1]; + if (has_iter_size()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(36, this->iter_size(), output); + } + + // optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + if (has_snapshot_format()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 37, this->snapshot_format(), output); + } + + // optional float rms_decay = 38 [default = 0.99]; + if (has_rms_decay()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(38, this->rms_decay(), output); + } + + // optional float momentum2 = 39 [default = 0.999]; + if (has_momentum2()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(39, this->momentum2(), output); + } + + // optional string type = 40 [default = "SGD"]; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 40, this->type(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.SolverParameter) +} + +::google::protobuf::uint8* SolverParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.SolverParameter) + // optional string train_net = 1; + if (has_train_net()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->train_net().data(), this->train_net().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.train_net"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->train_net(), target); + } + + // repeated string test_net = 2; + for (int i = 0; i < this->test_net_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->test_net(i).data(), this->test_net(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.test_net"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(2, this->test_net(i), target); + } + + // repeated int32 test_iter = 3; + for (int i = 0; i < this->test_iter_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArray(3, this->test_iter(i), target); + } + + // optional int32 test_interval = 4 [default = 0]; + if (has_test_interval()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->test_interval(), target); + } + + // optional float base_lr = 5; + if (has_base_lr()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->base_lr(), target); + } + + // optional int32 display = 6; + if (has_display()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->display(), target); + } + + // optional int32 max_iter = 7; + if (has_max_iter()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->max_iter(), target); + } + + // optional string lr_policy = 8; + if (has_lr_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->lr_policy().data(), this->lr_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.lr_policy"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->lr_policy(), target); + } + + // optional float gamma = 9; + if (has_gamma()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->gamma(), target); + } + + // optional float power = 10; + if (has_power()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->power(), target); + } + + // optional float momentum = 11; + if (has_momentum()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->momentum(), target); + } + + // optional float weight_decay = 12; + if (has_weight_decay()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->weight_decay(), target); + } + + // optional int32 stepsize = 13; + if (has_stepsize()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->stepsize(), target); + } + + // optional int32 snapshot = 14 [default = 0]; + if (has_snapshot()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->snapshot(), target); + } + + // optional string snapshot_prefix = 15; + if (has_snapshot_prefix()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->snapshot_prefix().data(), this->snapshot_prefix().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.snapshot_prefix"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 15, this->snapshot_prefix(), target); + } + + // optional bool snapshot_diff = 16 [default = false]; + if (has_snapshot_diff()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->snapshot_diff(), target); + } + + // optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + if (has_solver_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 17, this->solver_mode(), target); + } + + // optional int32 device_id = 18 [default = 0]; + if (has_device_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(18, this->device_id(), target); + } + + // optional bool test_compute_loss = 19 [default = false]; + if (has_test_compute_loss()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(19, this->test_compute_loss(), target); + } + + // optional int64 random_seed = 20 [default = -1]; + if (has_random_seed()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(20, this->random_seed(), target); + } + + // optional .caffe.NetParameter train_net_param = 21; + if (has_train_net_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 21, *this->train_net_param_, false, target); + } + + // repeated .caffe.NetParameter test_net_param = 22; + for (unsigned int i = 0, n = this->test_net_param_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 22, this->test_net_param(i), false, target); + } + + // optional bool debug_info = 23 [default = false]; + if (has_debug_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(23, this->debug_info(), target); + } + + // optional string net = 24; + if (has_net()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->net().data(), this->net().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.net"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 24, this->net(), target); + } + + // optional .caffe.NetParameter net_param = 25; + if (has_net_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 25, *this->net_param_, false, target); + } + + // optional .caffe.NetState train_state = 26; + if (has_train_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 26, *this->train_state_, false, target); + } + + // repeated .caffe.NetState test_state = 27; + for (unsigned int i = 0, n = this->test_state_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 27, this->test_state(i), false, target); + } + + // optional bool snapshot_after_train = 28 [default = true]; + if (has_snapshot_after_train()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(28, this->snapshot_after_train(), target); + } + + // optional string regularization_type = 29 [default = "L2"]; + if (has_regularization_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->regularization_type().data(), this->regularization_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.regularization_type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 29, this->regularization_type(), target); + } + + // optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + if (has_solver_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 30, this->solver_type(), target); + } + + // optional float delta = 31 [default = 1e-08]; + if (has_delta()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(31, this->delta(), target); + } + + // optional bool test_initialization = 32 [default = true]; + if (has_test_initialization()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(32, this->test_initialization(), target); + } + + // optional int32 average_loss = 33 [default = 1]; + if (has_average_loss()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(33, this->average_loss(), target); + } + + // repeated int32 stepvalue = 34; + for (int i = 0; i < this->stepvalue_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArray(34, this->stepvalue(i), target); + } + + // optional float clip_gradients = 35 [default = -1]; + if (has_clip_gradients()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(35, this->clip_gradients(), target); + } + + // optional int32 iter_size = 36 [default = 1]; + if (has_iter_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(36, this->iter_size(), target); + } + + // optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + if (has_snapshot_format()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 37, this->snapshot_format(), target); + } + + // optional float rms_decay = 38 [default = 0.99]; + if (has_rms_decay()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(38, this->rms_decay(), target); + } + + // optional float momentum2 = 39 [default = 0.999]; + if (has_momentum2()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(39, this->momentum2(), target); + } + + // optional string type = 40 [default = "SGD"]; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverParameter.type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 40, this->type(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.SolverParameter) + return target; +} + +size_t SolverParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.SolverParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 87u) { + // optional string net = 24; + if (has_net()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->net()); + } + + // optional .caffe.NetParameter net_param = 25; + if (has_net_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->net_param_); + } + + // optional string train_net = 1; + if (has_train_net()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->train_net()); + } + + // optional .caffe.NetParameter train_net_param = 21; + if (has_train_net_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->train_net_param_); + } + + // optional .caffe.NetState train_state = 26; + if (has_train_state()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->train_state_); + } + + } + if (_has_bits_[9 / 32] & 65024u) { + // optional int32 test_interval = 4 [default = 0]; + if (has_test_interval()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->test_interval()); + } + + // optional bool test_compute_loss = 19 [default = false]; + if (has_test_compute_loss()) { + total_size += 2 + 1; + } + + // optional bool test_initialization = 32 [default = true]; + if (has_test_initialization()) { + total_size += 2 + 1; + } + + // optional float base_lr = 5; + if (has_base_lr()) { + total_size += 1 + 4; + } + + // optional int32 display = 6; + if (has_display()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->display()); + } + + // optional int32 average_loss = 33 [default = 1]; + if (has_average_loss()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->average_loss()); + } + + // optional int32 max_iter = 7; + if (has_max_iter()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->max_iter()); + } + + } + if (_has_bits_[16 / 32] & 16711680u) { + // optional int32 iter_size = 36 [default = 1]; + if (has_iter_size()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->iter_size()); + } + + // optional string lr_policy = 8; + if (has_lr_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->lr_policy()); + } + + // optional float gamma = 9; + if (has_gamma()) { + total_size += 1 + 4; + } + + // optional float power = 10; + if (has_power()) { + total_size += 1 + 4; + } + + // optional float momentum = 11; + if (has_momentum()) { + total_size += 1 + 4; + } + + // optional float weight_decay = 12; + if (has_weight_decay()) { + total_size += 1 + 4; + } + + // optional string regularization_type = 29 [default = "L2"]; + if (has_regularization_type()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->regularization_type()); + } + + // optional int32 stepsize = 13; + if (has_stepsize()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->stepsize()); + } + + } + if (_has_bits_[25 / 32] & 4261412864u) { + // optional float clip_gradients = 35 [default = -1]; + if (has_clip_gradients()) { + total_size += 2 + 4; + } + + // optional int32 snapshot = 14 [default = 0]; + if (has_snapshot()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->snapshot()); + } + + // optional string snapshot_prefix = 15; + if (has_snapshot_prefix()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->snapshot_prefix()); + } + + // optional bool snapshot_diff = 16 [default = false]; + if (has_snapshot_diff()) { + total_size += 2 + 1; + } + + // optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + if (has_snapshot_format()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->snapshot_format()); + } + + // optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + if (has_solver_mode()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->solver_mode()); + } + + // optional int32 device_id = 18 [default = 0]; + if (has_device_id()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->device_id()); + } + + } + if (_has_bits_[32 / 32] & 255u) { + // optional int64 random_seed = 20 [default = -1]; + if (has_random_seed()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->random_seed()); + } + + // optional string type = 40 [default = "SGD"]; + if (has_type()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + // optional float delta = 31 [default = 1e-08]; + if (has_delta()) { + total_size += 2 + 4; + } + + // optional float momentum2 = 39 [default = 0.999]; + if (has_momentum2()) { + total_size += 2 + 4; + } + + // optional float rms_decay = 38 [default = 0.99]; + if (has_rms_decay()) { + total_size += 2 + 4; + } + + // optional bool debug_info = 23 [default = false]; + if (has_debug_info()) { + total_size += 2 + 1; + } + + // optional bool snapshot_after_train = 28 [default = true]; + if (has_snapshot_after_train()) { + total_size += 2 + 1; + } + + // optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + if (has_solver_type()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->solver_type()); + } + + } + // repeated string test_net = 2; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->test_net_size()); + for (int i = 0; i < this->test_net_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->test_net(i)); + } + + // repeated .caffe.NetParameter test_net_param = 22; + { + unsigned int count = this->test_net_param_size(); + total_size += 2UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->test_net_param(i)); + } + } + + // repeated .caffe.NetState test_state = 27; + { + unsigned int count = this->test_state_size(); + total_size += 2UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->test_state(i)); + } + } + + // repeated int32 test_iter = 3; + { + size_t data_size = 0; + unsigned int count = this->test_iter_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->test_iter(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->test_iter_size()); + total_size += data_size; + } + + // repeated int32 stepvalue = 34; + { + size_t data_size = 0; + unsigned int count = this->stepvalue_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->stepvalue(i)); + } + total_size += 2 * + ::google::protobuf::internal::FromIntSize(this->stepvalue_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SolverParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.SolverParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const SolverParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.SolverParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.SolverParameter) + UnsafeMergeFrom(*source); + } +} + +void SolverParameter::MergeFrom(const SolverParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.SolverParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void SolverParameter::UnsafeMergeFrom(const SolverParameter& from) { + GOOGLE_DCHECK(&from != this); + test_net_.UnsafeMergeFrom(from.test_net_); + test_net_param_.MergeFrom(from.test_net_param_); + test_state_.MergeFrom(from.test_state_); + test_iter_.UnsafeMergeFrom(from.test_iter_); + stepvalue_.UnsafeMergeFrom(from.stepvalue_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_net()) { + set_has_net(); + net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.net_); + } + if (from.has_net_param()) { + mutable_net_param()->::caffe::NetParameter::MergeFrom(from.net_param()); + } + if (from.has_train_net()) { + set_has_train_net(); + train_net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.train_net_); + } + if (from.has_train_net_param()) { + mutable_train_net_param()->::caffe::NetParameter::MergeFrom(from.train_net_param()); + } + if (from.has_train_state()) { + mutable_train_state()->::caffe::NetState::MergeFrom(from.train_state()); + } + } + if (from._has_bits_[9 / 32] & (0xffu << (9 % 32))) { + if (from.has_test_interval()) { + set_test_interval(from.test_interval()); + } + if (from.has_test_compute_loss()) { + set_test_compute_loss(from.test_compute_loss()); + } + if (from.has_test_initialization()) { + set_test_initialization(from.test_initialization()); + } + if (from.has_base_lr()) { + set_base_lr(from.base_lr()); + } + if (from.has_display()) { + set_display(from.display()); + } + if (from.has_average_loss()) { + set_average_loss(from.average_loss()); + } + if (from.has_max_iter()) { + set_max_iter(from.max_iter()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from.has_iter_size()) { + set_iter_size(from.iter_size()); + } + if (from.has_lr_policy()) { + set_has_lr_policy(); + lr_policy_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.lr_policy_); + } + if (from.has_gamma()) { + set_gamma(from.gamma()); + } + if (from.has_power()) { + set_power(from.power()); + } + if (from.has_momentum()) { + set_momentum(from.momentum()); + } + if (from.has_weight_decay()) { + set_weight_decay(from.weight_decay()); + } + if (from.has_regularization_type()) { + set_has_regularization_type(); + regularization_type_.AssignWithDefault(_default_regularization_type_, from.regularization_type_); + } + if (from.has_stepsize()) { + set_stepsize(from.stepsize()); + } + } + if (from._has_bits_[25 / 32] & (0xffu << (25 % 32))) { + if (from.has_clip_gradients()) { + set_clip_gradients(from.clip_gradients()); + } + if (from.has_snapshot()) { + set_snapshot(from.snapshot()); + } + if (from.has_snapshot_prefix()) { + set_has_snapshot_prefix(); + snapshot_prefix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_prefix_); + } + if (from.has_snapshot_diff()) { + set_snapshot_diff(from.snapshot_diff()); + } + if (from.has_snapshot_format()) { + set_snapshot_format(from.snapshot_format()); + } + if (from.has_solver_mode()) { + set_solver_mode(from.solver_mode()); + } + if (from.has_device_id()) { + set_device_id(from.device_id()); + } + } + if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) { + if (from.has_random_seed()) { + set_random_seed(from.random_seed()); + } + if (from.has_type()) { + set_has_type(); + type_.AssignWithDefault(_default_type_, from.type_); + } + if (from.has_delta()) { + set_delta(from.delta()); + } + if (from.has_momentum2()) { + set_momentum2(from.momentum2()); + } + if (from.has_rms_decay()) { + set_rms_decay(from.rms_decay()); + } + if (from.has_debug_info()) { + set_debug_info(from.debug_info()); + } + if (from.has_snapshot_after_train()) { + set_snapshot_after_train(from.snapshot_after_train()); + } + if (from.has_solver_type()) { + set_solver_type(from.solver_type()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void SolverParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.SolverParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SolverParameter::CopyFrom(const SolverParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.SolverParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool SolverParameter::IsInitialized() const { + + return true; +} + +void SolverParameter::Swap(SolverParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void SolverParameter::InternalSwap(SolverParameter* other) { + net_.Swap(&other->net_); + std::swap(net_param_, other->net_param_); + train_net_.Swap(&other->train_net_); + test_net_.UnsafeArenaSwap(&other->test_net_); + std::swap(train_net_param_, other->train_net_param_); + test_net_param_.UnsafeArenaSwap(&other->test_net_param_); + std::swap(train_state_, other->train_state_); + test_state_.UnsafeArenaSwap(&other->test_state_); + test_iter_.UnsafeArenaSwap(&other->test_iter_); + std::swap(test_interval_, other->test_interval_); + std::swap(test_compute_loss_, other->test_compute_loss_); + std::swap(test_initialization_, other->test_initialization_); + std::swap(base_lr_, other->base_lr_); + std::swap(display_, other->display_); + std::swap(average_loss_, other->average_loss_); + std::swap(max_iter_, other->max_iter_); + std::swap(iter_size_, other->iter_size_); + lr_policy_.Swap(&other->lr_policy_); + std::swap(gamma_, other->gamma_); + std::swap(power_, other->power_); + std::swap(momentum_, other->momentum_); + std::swap(weight_decay_, other->weight_decay_); + regularization_type_.Swap(&other->regularization_type_); + std::swap(stepsize_, other->stepsize_); + stepvalue_.UnsafeArenaSwap(&other->stepvalue_); + std::swap(clip_gradients_, other->clip_gradients_); + std::swap(snapshot_, other->snapshot_); + snapshot_prefix_.Swap(&other->snapshot_prefix_); + std::swap(snapshot_diff_, other->snapshot_diff_); + std::swap(snapshot_format_, other->snapshot_format_); + std::swap(solver_mode_, other->solver_mode_); + std::swap(device_id_, other->device_id_); + std::swap(random_seed_, other->random_seed_); + type_.Swap(&other->type_); + std::swap(delta_, other->delta_); + std::swap(momentum2_, other->momentum2_); + std::swap(rms_decay_, other->rms_decay_); + std::swap(debug_info_, other->debug_info_); + std::swap(snapshot_after_train_, other->snapshot_after_train_); + std::swap(solver_type_, other->solver_type_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_has_bits_[1], other->_has_bits_[1]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata SolverParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SolverParameter_descriptor_; + metadata.reflection = SolverParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// SolverParameter + +// optional string net = 24; +bool SolverParameter::has_net() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void SolverParameter::set_has_net() { + _has_bits_[0] |= 0x00000001u; +} +void SolverParameter::clear_has_net() { + _has_bits_[0] &= ~0x00000001u; +} +void SolverParameter::clear_net() { + net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_net(); +} +const ::std::string& SolverParameter::net() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.net) + return net_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_net(const ::std::string& value) { + set_has_net(); + net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.net) +} +void SolverParameter::set_net(const char* value) { + set_has_net(); + net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.net) +} +void SolverParameter::set_net(const char* value, size_t size) { + set_has_net(); + net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.net) +} +::std::string* SolverParameter::mutable_net() { + set_has_net(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.net) + return net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SolverParameter::release_net() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.net) + clear_has_net(); + return net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_allocated_net(::std::string* net) { + if (net != NULL) { + set_has_net(); + } else { + clear_has_net(); + } + net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), net); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.net) +} + +// optional .caffe.NetParameter net_param = 25; +bool SolverParameter::has_net_param() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void SolverParameter::set_has_net_param() { + _has_bits_[0] |= 0x00000002u; +} +void SolverParameter::clear_has_net_param() { + _has_bits_[0] &= ~0x00000002u; +} +void SolverParameter::clear_net_param() { + if (net_param_ != NULL) net_param_->::caffe::NetParameter::Clear(); + clear_has_net_param(); +} +const ::caffe::NetParameter& SolverParameter::net_param() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.net_param) + return net_param_ != NULL ? *net_param_ + : *::caffe::NetParameter::internal_default_instance(); +} +::caffe::NetParameter* SolverParameter::mutable_net_param() { + set_has_net_param(); + if (net_param_ == NULL) { + net_param_ = new ::caffe::NetParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.net_param) + return net_param_; +} +::caffe::NetParameter* SolverParameter::release_net_param() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.net_param) + clear_has_net_param(); + ::caffe::NetParameter* temp = net_param_; + net_param_ = NULL; + return temp; +} +void SolverParameter::set_allocated_net_param(::caffe::NetParameter* net_param) { + delete net_param_; + net_param_ = net_param; + if (net_param) { + set_has_net_param(); + } else { + clear_has_net_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.net_param) +} + +// optional string train_net = 1; +bool SolverParameter::has_train_net() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void SolverParameter::set_has_train_net() { + _has_bits_[0] |= 0x00000004u; +} +void SolverParameter::clear_has_train_net() { + _has_bits_[0] &= ~0x00000004u; +} +void SolverParameter::clear_train_net() { + train_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_train_net(); +} +const ::std::string& SolverParameter::train_net() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.train_net) + return train_net_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_train_net(const ::std::string& value) { + set_has_train_net(); + train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.train_net) +} +void SolverParameter::set_train_net(const char* value) { + set_has_train_net(); + train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.train_net) +} +void SolverParameter::set_train_net(const char* value, size_t size) { + set_has_train_net(); + train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.train_net) +} +::std::string* SolverParameter::mutable_train_net() { + set_has_train_net(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_net) + return train_net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SolverParameter::release_train_net() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.train_net) + clear_has_train_net(); + return train_net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_allocated_train_net(::std::string* train_net) { + if (train_net != NULL) { + set_has_train_net(); + } else { + clear_has_train_net(); + } + train_net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), train_net); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_net) +} + +// repeated string test_net = 2; +int SolverParameter::test_net_size() const { + return test_net_.size(); +} +void SolverParameter::clear_test_net() { + test_net_.Clear(); +} +const ::std::string& SolverParameter::test_net(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_net) + return test_net_.Get(index); +} +::std::string* SolverParameter::mutable_test_net(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_net) + return test_net_.Mutable(index); +} +void SolverParameter::set_test_net(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_net) + test_net_.Mutable(index)->assign(value); +} +void SolverParameter::set_test_net(int index, const char* value) { + test_net_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.test_net) +} +void SolverParameter::set_test_net(int index, const char* value, size_t size) { + test_net_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.test_net) +} +::std::string* SolverParameter::add_test_net() { + // @@protoc_insertion_point(field_add_mutable:caffe.SolverParameter.test_net) + return test_net_.Add(); +} +void SolverParameter::add_test_net(const ::std::string& value) { + test_net_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_net) +} +void SolverParameter::add_test_net(const char* value) { + test_net_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.SolverParameter.test_net) +} +void SolverParameter::add_test_net(const char* value, size_t size) { + test_net_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.SolverParameter.test_net) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +SolverParameter::test_net() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_net) + return test_net_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +SolverParameter::mutable_test_net() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_net) + return &test_net_; +} + +// optional .caffe.NetParameter train_net_param = 21; +bool SolverParameter::has_train_net_param() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void SolverParameter::set_has_train_net_param() { + _has_bits_[0] |= 0x00000010u; +} +void SolverParameter::clear_has_train_net_param() { + _has_bits_[0] &= ~0x00000010u; +} +void SolverParameter::clear_train_net_param() { + if (train_net_param_ != NULL) train_net_param_->::caffe::NetParameter::Clear(); + clear_has_train_net_param(); +} +const ::caffe::NetParameter& SolverParameter::train_net_param() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.train_net_param) + return train_net_param_ != NULL ? *train_net_param_ + : *::caffe::NetParameter::internal_default_instance(); +} +::caffe::NetParameter* SolverParameter::mutable_train_net_param() { + set_has_train_net_param(); + if (train_net_param_ == NULL) { + train_net_param_ = new ::caffe::NetParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_net_param) + return train_net_param_; +} +::caffe::NetParameter* SolverParameter::release_train_net_param() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.train_net_param) + clear_has_train_net_param(); + ::caffe::NetParameter* temp = train_net_param_; + train_net_param_ = NULL; + return temp; +} +void SolverParameter::set_allocated_train_net_param(::caffe::NetParameter* train_net_param) { + delete train_net_param_; + train_net_param_ = train_net_param; + if (train_net_param) { + set_has_train_net_param(); + } else { + clear_has_train_net_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_net_param) +} + +// repeated .caffe.NetParameter test_net_param = 22; +int SolverParameter::test_net_param_size() const { + return test_net_param_.size(); +} +void SolverParameter::clear_test_net_param() { + test_net_param_.Clear(); +} +const ::caffe::NetParameter& SolverParameter::test_net_param(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_net_param) + return test_net_param_.Get(index); +} +::caffe::NetParameter* SolverParameter::mutable_test_net_param(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_net_param) + return test_net_param_.Mutable(index); +} +::caffe::NetParameter* SolverParameter::add_test_net_param() { + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_net_param) + return test_net_param_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >* +SolverParameter::mutable_test_net_param() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_net_param) + return &test_net_param_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >& +SolverParameter::test_net_param() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_net_param) + return test_net_param_; +} + +// optional .caffe.NetState train_state = 26; +bool SolverParameter::has_train_state() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void SolverParameter::set_has_train_state() { + _has_bits_[0] |= 0x00000040u; +} +void SolverParameter::clear_has_train_state() { + _has_bits_[0] &= ~0x00000040u; +} +void SolverParameter::clear_train_state() { + if (train_state_ != NULL) train_state_->::caffe::NetState::Clear(); + clear_has_train_state(); +} +const ::caffe::NetState& SolverParameter::train_state() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.train_state) + return train_state_ != NULL ? *train_state_ + : *::caffe::NetState::internal_default_instance(); +} +::caffe::NetState* SolverParameter::mutable_train_state() { + set_has_train_state(); + if (train_state_ == NULL) { + train_state_ = new ::caffe::NetState; + } + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_state) + return train_state_; +} +::caffe::NetState* SolverParameter::release_train_state() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.train_state) + clear_has_train_state(); + ::caffe::NetState* temp = train_state_; + train_state_ = NULL; + return temp; +} +void SolverParameter::set_allocated_train_state(::caffe::NetState* train_state) { + delete train_state_; + train_state_ = train_state; + if (train_state) { + set_has_train_state(); + } else { + clear_has_train_state(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_state) +} + +// repeated .caffe.NetState test_state = 27; +int SolverParameter::test_state_size() const { + return test_state_.size(); +} +void SolverParameter::clear_test_state() { + test_state_.Clear(); +} +const ::caffe::NetState& SolverParameter::test_state(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_state) + return test_state_.Get(index); +} +::caffe::NetState* SolverParameter::mutable_test_state(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_state) + return test_state_.Mutable(index); +} +::caffe::NetState* SolverParameter::add_test_state() { + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_state) + return test_state_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::NetState >* +SolverParameter::mutable_test_state() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_state) + return &test_state_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::NetState >& +SolverParameter::test_state() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_state) + return test_state_; +} + +// repeated int32 test_iter = 3; +int SolverParameter::test_iter_size() const { + return test_iter_.size(); +} +void SolverParameter::clear_test_iter() { + test_iter_.Clear(); +} +::google::protobuf::int32 SolverParameter::test_iter(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_iter) + return test_iter_.Get(index); +} +void SolverParameter::set_test_iter(int index, ::google::protobuf::int32 value) { + test_iter_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_iter) +} +void SolverParameter::add_test_iter(::google::protobuf::int32 value) { + test_iter_.Add(value); + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_iter) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +SolverParameter::test_iter() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_iter) + return test_iter_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +SolverParameter::mutable_test_iter() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_iter) + return &test_iter_; +} + +// optional int32 test_interval = 4 [default = 0]; +bool SolverParameter::has_test_interval() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void SolverParameter::set_has_test_interval() { + _has_bits_[0] |= 0x00000200u; +} +void SolverParameter::clear_has_test_interval() { + _has_bits_[0] &= ~0x00000200u; +} +void SolverParameter::clear_test_interval() { + test_interval_ = 0; + clear_has_test_interval(); +} +::google::protobuf::int32 SolverParameter::test_interval() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_interval) + return test_interval_; +} +void SolverParameter::set_test_interval(::google::protobuf::int32 value) { + set_has_test_interval(); + test_interval_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_interval) +} + +// optional bool test_compute_loss = 19 [default = false]; +bool SolverParameter::has_test_compute_loss() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +void SolverParameter::set_has_test_compute_loss() { + _has_bits_[0] |= 0x00000400u; +} +void SolverParameter::clear_has_test_compute_loss() { + _has_bits_[0] &= ~0x00000400u; +} +void SolverParameter::clear_test_compute_loss() { + test_compute_loss_ = false; + clear_has_test_compute_loss(); +} +bool SolverParameter::test_compute_loss() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_compute_loss) + return test_compute_loss_; +} +void SolverParameter::set_test_compute_loss(bool value) { + set_has_test_compute_loss(); + test_compute_loss_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_compute_loss) +} + +// optional bool test_initialization = 32 [default = true]; +bool SolverParameter::has_test_initialization() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void SolverParameter::set_has_test_initialization() { + _has_bits_[0] |= 0x00000800u; +} +void SolverParameter::clear_has_test_initialization() { + _has_bits_[0] &= ~0x00000800u; +} +void SolverParameter::clear_test_initialization() { + test_initialization_ = true; + clear_has_test_initialization(); +} +bool SolverParameter::test_initialization() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_initialization) + return test_initialization_; +} +void SolverParameter::set_test_initialization(bool value) { + set_has_test_initialization(); + test_initialization_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_initialization) +} + +// optional float base_lr = 5; +bool SolverParameter::has_base_lr() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +void SolverParameter::set_has_base_lr() { + _has_bits_[0] |= 0x00001000u; +} +void SolverParameter::clear_has_base_lr() { + _has_bits_[0] &= ~0x00001000u; +} +void SolverParameter::clear_base_lr() { + base_lr_ = 0; + clear_has_base_lr(); +} +float SolverParameter::base_lr() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.base_lr) + return base_lr_; +} +void SolverParameter::set_base_lr(float value) { + set_has_base_lr(); + base_lr_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.base_lr) +} + +// optional int32 display = 6; +bool SolverParameter::has_display() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +void SolverParameter::set_has_display() { + _has_bits_[0] |= 0x00002000u; +} +void SolverParameter::clear_has_display() { + _has_bits_[0] &= ~0x00002000u; +} +void SolverParameter::clear_display() { + display_ = 0; + clear_has_display(); +} +::google::protobuf::int32 SolverParameter::display() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.display) + return display_; +} +void SolverParameter::set_display(::google::protobuf::int32 value) { + set_has_display(); + display_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.display) +} + +// optional int32 average_loss = 33 [default = 1]; +bool SolverParameter::has_average_loss() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +void SolverParameter::set_has_average_loss() { + _has_bits_[0] |= 0x00004000u; +} +void SolverParameter::clear_has_average_loss() { + _has_bits_[0] &= ~0x00004000u; +} +void SolverParameter::clear_average_loss() { + average_loss_ = 1; + clear_has_average_loss(); +} +::google::protobuf::int32 SolverParameter::average_loss() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.average_loss) + return average_loss_; +} +void SolverParameter::set_average_loss(::google::protobuf::int32 value) { + set_has_average_loss(); + average_loss_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.average_loss) +} + +// optional int32 max_iter = 7; +bool SolverParameter::has_max_iter() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +void SolverParameter::set_has_max_iter() { + _has_bits_[0] |= 0x00008000u; +} +void SolverParameter::clear_has_max_iter() { + _has_bits_[0] &= ~0x00008000u; +} +void SolverParameter::clear_max_iter() { + max_iter_ = 0; + clear_has_max_iter(); +} +::google::protobuf::int32 SolverParameter::max_iter() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.max_iter) + return max_iter_; +} +void SolverParameter::set_max_iter(::google::protobuf::int32 value) { + set_has_max_iter(); + max_iter_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.max_iter) +} + +// optional int32 iter_size = 36 [default = 1]; +bool SolverParameter::has_iter_size() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +void SolverParameter::set_has_iter_size() { + _has_bits_[0] |= 0x00010000u; +} +void SolverParameter::clear_has_iter_size() { + _has_bits_[0] &= ~0x00010000u; +} +void SolverParameter::clear_iter_size() { + iter_size_ = 1; + clear_has_iter_size(); +} +::google::protobuf::int32 SolverParameter::iter_size() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.iter_size) + return iter_size_; +} +void SolverParameter::set_iter_size(::google::protobuf::int32 value) { + set_has_iter_size(); + iter_size_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.iter_size) +} + +// optional string lr_policy = 8; +bool SolverParameter::has_lr_policy() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +void SolverParameter::set_has_lr_policy() { + _has_bits_[0] |= 0x00020000u; +} +void SolverParameter::clear_has_lr_policy() { + _has_bits_[0] &= ~0x00020000u; +} +void SolverParameter::clear_lr_policy() { + lr_policy_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_lr_policy(); +} +const ::std::string& SolverParameter::lr_policy() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.lr_policy) + return lr_policy_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_lr_policy(const ::std::string& value) { + set_has_lr_policy(); + lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.lr_policy) +} +void SolverParameter::set_lr_policy(const char* value) { + set_has_lr_policy(); + lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.lr_policy) +} +void SolverParameter::set_lr_policy(const char* value, size_t size) { + set_has_lr_policy(); + lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.lr_policy) +} +::std::string* SolverParameter::mutable_lr_policy() { + set_has_lr_policy(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.lr_policy) + return lr_policy_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SolverParameter::release_lr_policy() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.lr_policy) + clear_has_lr_policy(); + return lr_policy_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_allocated_lr_policy(::std::string* lr_policy) { + if (lr_policy != NULL) { + set_has_lr_policy(); + } else { + clear_has_lr_policy(); + } + lr_policy_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), lr_policy); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.lr_policy) +} + +// optional float gamma = 9; +bool SolverParameter::has_gamma() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +void SolverParameter::set_has_gamma() { + _has_bits_[0] |= 0x00040000u; +} +void SolverParameter::clear_has_gamma() { + _has_bits_[0] &= ~0x00040000u; +} +void SolverParameter::clear_gamma() { + gamma_ = 0; + clear_has_gamma(); +} +float SolverParameter::gamma() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.gamma) + return gamma_; +} +void SolverParameter::set_gamma(float value) { + set_has_gamma(); + gamma_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.gamma) +} + +// optional float power = 10; +bool SolverParameter::has_power() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +void SolverParameter::set_has_power() { + _has_bits_[0] |= 0x00080000u; +} +void SolverParameter::clear_has_power() { + _has_bits_[0] &= ~0x00080000u; +} +void SolverParameter::clear_power() { + power_ = 0; + clear_has_power(); +} +float SolverParameter::power() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.power) + return power_; +} +void SolverParameter::set_power(float value) { + set_has_power(); + power_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.power) +} + +// optional float momentum = 11; +bool SolverParameter::has_momentum() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +void SolverParameter::set_has_momentum() { + _has_bits_[0] |= 0x00100000u; +} +void SolverParameter::clear_has_momentum() { + _has_bits_[0] &= ~0x00100000u; +} +void SolverParameter::clear_momentum() { + momentum_ = 0; + clear_has_momentum(); +} +float SolverParameter::momentum() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.momentum) + return momentum_; +} +void SolverParameter::set_momentum(float value) { + set_has_momentum(); + momentum_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.momentum) +} + +// optional float weight_decay = 12; +bool SolverParameter::has_weight_decay() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +void SolverParameter::set_has_weight_decay() { + _has_bits_[0] |= 0x00200000u; +} +void SolverParameter::clear_has_weight_decay() { + _has_bits_[0] &= ~0x00200000u; +} +void SolverParameter::clear_weight_decay() { + weight_decay_ = 0; + clear_has_weight_decay(); +} +float SolverParameter::weight_decay() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.weight_decay) + return weight_decay_; +} +void SolverParameter::set_weight_decay(float value) { + set_has_weight_decay(); + weight_decay_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.weight_decay) +} + +// optional string regularization_type = 29 [default = "L2"]; +bool SolverParameter::has_regularization_type() const { + return (_has_bits_[0] & 0x00400000u) != 0; +} +void SolverParameter::set_has_regularization_type() { + _has_bits_[0] |= 0x00400000u; +} +void SolverParameter::clear_has_regularization_type() { + _has_bits_[0] &= ~0x00400000u; +} +void SolverParameter::clear_regularization_type() { + regularization_type_.ClearToDefaultNoArena(_default_regularization_type_); + clear_has_regularization_type(); +} +const ::std::string& SolverParameter::regularization_type() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.regularization_type) + return regularization_type_.GetNoArena(_default_regularization_type_); +} +void SolverParameter::set_regularization_type(const ::std::string& value) { + set_has_regularization_type(); + regularization_type_.SetNoArena(_default_regularization_type_, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.regularization_type) +} +void SolverParameter::set_regularization_type(const char* value) { + set_has_regularization_type(); + regularization_type_.SetNoArena(_default_regularization_type_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.regularization_type) +} +void SolverParameter::set_regularization_type(const char* value, size_t size) { + set_has_regularization_type(); + regularization_type_.SetNoArena(_default_regularization_type_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.regularization_type) +} +::std::string* SolverParameter::mutable_regularization_type() { + set_has_regularization_type(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.regularization_type) + return regularization_type_.MutableNoArena(_default_regularization_type_); +} +::std::string* SolverParameter::release_regularization_type() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.regularization_type) + clear_has_regularization_type(); + return regularization_type_.ReleaseNoArena(_default_regularization_type_); +} +void SolverParameter::set_allocated_regularization_type(::std::string* regularization_type) { + if (regularization_type != NULL) { + set_has_regularization_type(); + } else { + clear_has_regularization_type(); + } + regularization_type_.SetAllocatedNoArena(_default_regularization_type_, regularization_type); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.regularization_type) +} + +// optional int32 stepsize = 13; +bool SolverParameter::has_stepsize() const { + return (_has_bits_[0] & 0x00800000u) != 0; +} +void SolverParameter::set_has_stepsize() { + _has_bits_[0] |= 0x00800000u; +} +void SolverParameter::clear_has_stepsize() { + _has_bits_[0] &= ~0x00800000u; +} +void SolverParameter::clear_stepsize() { + stepsize_ = 0; + clear_has_stepsize(); +} +::google::protobuf::int32 SolverParameter::stepsize() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.stepsize) + return stepsize_; +} +void SolverParameter::set_stepsize(::google::protobuf::int32 value) { + set_has_stepsize(); + stepsize_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.stepsize) +} + +// repeated int32 stepvalue = 34; +int SolverParameter::stepvalue_size() const { + return stepvalue_.size(); +} +void SolverParameter::clear_stepvalue() { + stepvalue_.Clear(); +} +::google::protobuf::int32 SolverParameter::stepvalue(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.stepvalue) + return stepvalue_.Get(index); +} +void SolverParameter::set_stepvalue(int index, ::google::protobuf::int32 value) { + stepvalue_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.stepvalue) +} +void SolverParameter::add_stepvalue(::google::protobuf::int32 value) { + stepvalue_.Add(value); + // @@protoc_insertion_point(field_add:caffe.SolverParameter.stepvalue) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +SolverParameter::stepvalue() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.stepvalue) + return stepvalue_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +SolverParameter::mutable_stepvalue() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.stepvalue) + return &stepvalue_; +} + +// optional float clip_gradients = 35 [default = -1]; +bool SolverParameter::has_clip_gradients() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +void SolverParameter::set_has_clip_gradients() { + _has_bits_[0] |= 0x02000000u; +} +void SolverParameter::clear_has_clip_gradients() { + _has_bits_[0] &= ~0x02000000u; +} +void SolverParameter::clear_clip_gradients() { + clip_gradients_ = -1; + clear_has_clip_gradients(); +} +float SolverParameter::clip_gradients() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.clip_gradients) + return clip_gradients_; +} +void SolverParameter::set_clip_gradients(float value) { + set_has_clip_gradients(); + clip_gradients_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.clip_gradients) +} + +// optional int32 snapshot = 14 [default = 0]; +bool SolverParameter::has_snapshot() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +void SolverParameter::set_has_snapshot() { + _has_bits_[0] |= 0x04000000u; +} +void SolverParameter::clear_has_snapshot() { + _has_bits_[0] &= ~0x04000000u; +} +void SolverParameter::clear_snapshot() { + snapshot_ = 0; + clear_has_snapshot(); +} +::google::protobuf::int32 SolverParameter::snapshot() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot) + return snapshot_; +} +void SolverParameter::set_snapshot(::google::protobuf::int32 value) { + set_has_snapshot(); + snapshot_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot) +} + +// optional string snapshot_prefix = 15; +bool SolverParameter::has_snapshot_prefix() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +void SolverParameter::set_has_snapshot_prefix() { + _has_bits_[0] |= 0x08000000u; +} +void SolverParameter::clear_has_snapshot_prefix() { + _has_bits_[0] &= ~0x08000000u; +} +void SolverParameter::clear_snapshot_prefix() { + snapshot_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_snapshot_prefix(); +} +const ::std::string& SolverParameter::snapshot_prefix() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_prefix) + return snapshot_prefix_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_snapshot_prefix(const ::std::string& value) { + set_has_snapshot_prefix(); + snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_prefix) +} +void SolverParameter::set_snapshot_prefix(const char* value) { + set_has_snapshot_prefix(); + snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.snapshot_prefix) +} +void SolverParameter::set_snapshot_prefix(const char* value, size_t size) { + set_has_snapshot_prefix(); + snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.snapshot_prefix) +} +::std::string* SolverParameter::mutable_snapshot_prefix() { + set_has_snapshot_prefix(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.snapshot_prefix) + return snapshot_prefix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SolverParameter::release_snapshot_prefix() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.snapshot_prefix) + clear_has_snapshot_prefix(); + return snapshot_prefix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverParameter::set_allocated_snapshot_prefix(::std::string* snapshot_prefix) { + if (snapshot_prefix != NULL) { + set_has_snapshot_prefix(); + } else { + clear_has_snapshot_prefix(); + } + snapshot_prefix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshot_prefix); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.snapshot_prefix) +} + +// optional bool snapshot_diff = 16 [default = false]; +bool SolverParameter::has_snapshot_diff() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +void SolverParameter::set_has_snapshot_diff() { + _has_bits_[0] |= 0x10000000u; +} +void SolverParameter::clear_has_snapshot_diff() { + _has_bits_[0] &= ~0x10000000u; +} +void SolverParameter::clear_snapshot_diff() { + snapshot_diff_ = false; + clear_has_snapshot_diff(); +} +bool SolverParameter::snapshot_diff() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_diff) + return snapshot_diff_; +} +void SolverParameter::set_snapshot_diff(bool value) { + set_has_snapshot_diff(); + snapshot_diff_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_diff) +} + +// optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; +bool SolverParameter::has_snapshot_format() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +void SolverParameter::set_has_snapshot_format() { + _has_bits_[0] |= 0x20000000u; +} +void SolverParameter::clear_has_snapshot_format() { + _has_bits_[0] &= ~0x20000000u; +} +void SolverParameter::clear_snapshot_format() { + snapshot_format_ = 1; + clear_has_snapshot_format(); +} +::caffe::SolverParameter_SnapshotFormat SolverParameter::snapshot_format() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_format) + return static_cast< ::caffe::SolverParameter_SnapshotFormat >(snapshot_format_); +} +void SolverParameter::set_snapshot_format(::caffe::SolverParameter_SnapshotFormat value) { + assert(::caffe::SolverParameter_SnapshotFormat_IsValid(value)); + set_has_snapshot_format(); + snapshot_format_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_format) +} + +// optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; +bool SolverParameter::has_solver_mode() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +void SolverParameter::set_has_solver_mode() { + _has_bits_[0] |= 0x40000000u; +} +void SolverParameter::clear_has_solver_mode() { + _has_bits_[0] &= ~0x40000000u; +} +void SolverParameter::clear_solver_mode() { + solver_mode_ = 1; + clear_has_solver_mode(); +} +::caffe::SolverParameter_SolverMode SolverParameter::solver_mode() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.solver_mode) + return static_cast< ::caffe::SolverParameter_SolverMode >(solver_mode_); +} +void SolverParameter::set_solver_mode(::caffe::SolverParameter_SolverMode value) { + assert(::caffe::SolverParameter_SolverMode_IsValid(value)); + set_has_solver_mode(); + solver_mode_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.solver_mode) +} + +// optional int32 device_id = 18 [default = 0]; +bool SolverParameter::has_device_id() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +void SolverParameter::set_has_device_id() { + _has_bits_[0] |= 0x80000000u; +} +void SolverParameter::clear_has_device_id() { + _has_bits_[0] &= ~0x80000000u; +} +void SolverParameter::clear_device_id() { + device_id_ = 0; + clear_has_device_id(); +} +::google::protobuf::int32 SolverParameter::device_id() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.device_id) + return device_id_; +} +void SolverParameter::set_device_id(::google::protobuf::int32 value) { + set_has_device_id(); + device_id_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.device_id) +} + +// optional int64 random_seed = 20 [default = -1]; +bool SolverParameter::has_random_seed() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +void SolverParameter::set_has_random_seed() { + _has_bits_[1] |= 0x00000001u; +} +void SolverParameter::clear_has_random_seed() { + _has_bits_[1] &= ~0x00000001u; +} +void SolverParameter::clear_random_seed() { + random_seed_ = GOOGLE_LONGLONG(-1); + clear_has_random_seed(); +} +::google::protobuf::int64 SolverParameter::random_seed() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.random_seed) + return random_seed_; +} +void SolverParameter::set_random_seed(::google::protobuf::int64 value) { + set_has_random_seed(); + random_seed_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.random_seed) +} + +// optional string type = 40 [default = "SGD"]; +bool SolverParameter::has_type() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +void SolverParameter::set_has_type() { + _has_bits_[1] |= 0x00000002u; +} +void SolverParameter::clear_has_type() { + _has_bits_[1] &= ~0x00000002u; +} +void SolverParameter::clear_type() { + type_.ClearToDefaultNoArena(_default_type_); + clear_has_type(); +} +const ::std::string& SolverParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.type) + return type_.GetNoArena(_default_type_); +} +void SolverParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(_default_type_, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.type) +} +void SolverParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(_default_type_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.type) +} +void SolverParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(_default_type_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.type) +} +::std::string* SolverParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.type) + return type_.MutableNoArena(_default_type_); +} +::std::string* SolverParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(_default_type_); +} +void SolverParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(_default_type_, type); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.type) +} + +// optional float delta = 31 [default = 1e-08]; +bool SolverParameter::has_delta() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +void SolverParameter::set_has_delta() { + _has_bits_[1] |= 0x00000004u; +} +void SolverParameter::clear_has_delta() { + _has_bits_[1] &= ~0x00000004u; +} +void SolverParameter::clear_delta() { + delta_ = 1e-08f; + clear_has_delta(); +} +float SolverParameter::delta() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.delta) + return delta_; +} +void SolverParameter::set_delta(float value) { + set_has_delta(); + delta_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.delta) +} + +// optional float momentum2 = 39 [default = 0.999]; +bool SolverParameter::has_momentum2() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +void SolverParameter::set_has_momentum2() { + _has_bits_[1] |= 0x00000008u; +} +void SolverParameter::clear_has_momentum2() { + _has_bits_[1] &= ~0x00000008u; +} +void SolverParameter::clear_momentum2() { + momentum2_ = 0.999f; + clear_has_momentum2(); +} +float SolverParameter::momentum2() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.momentum2) + return momentum2_; +} +void SolverParameter::set_momentum2(float value) { + set_has_momentum2(); + momentum2_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.momentum2) +} + +// optional float rms_decay = 38 [default = 0.99]; +bool SolverParameter::has_rms_decay() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +void SolverParameter::set_has_rms_decay() { + _has_bits_[1] |= 0x00000010u; +} +void SolverParameter::clear_has_rms_decay() { + _has_bits_[1] &= ~0x00000010u; +} +void SolverParameter::clear_rms_decay() { + rms_decay_ = 0.99f; + clear_has_rms_decay(); +} +float SolverParameter::rms_decay() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.rms_decay) + return rms_decay_; +} +void SolverParameter::set_rms_decay(float value) { + set_has_rms_decay(); + rms_decay_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.rms_decay) +} + +// optional bool debug_info = 23 [default = false]; +bool SolverParameter::has_debug_info() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +void SolverParameter::set_has_debug_info() { + _has_bits_[1] |= 0x00000020u; +} +void SolverParameter::clear_has_debug_info() { + _has_bits_[1] &= ~0x00000020u; +} +void SolverParameter::clear_debug_info() { + debug_info_ = false; + clear_has_debug_info(); +} +bool SolverParameter::debug_info() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.debug_info) + return debug_info_; +} +void SolverParameter::set_debug_info(bool value) { + set_has_debug_info(); + debug_info_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.debug_info) +} + +// optional bool snapshot_after_train = 28 [default = true]; +bool SolverParameter::has_snapshot_after_train() const { + return (_has_bits_[1] & 0x00000040u) != 0; +} +void SolverParameter::set_has_snapshot_after_train() { + _has_bits_[1] |= 0x00000040u; +} +void SolverParameter::clear_has_snapshot_after_train() { + _has_bits_[1] &= ~0x00000040u; +} +void SolverParameter::clear_snapshot_after_train() { + snapshot_after_train_ = true; + clear_has_snapshot_after_train(); +} +bool SolverParameter::snapshot_after_train() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_after_train) + return snapshot_after_train_; +} +void SolverParameter::set_snapshot_after_train(bool value) { + set_has_snapshot_after_train(); + snapshot_after_train_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_after_train) +} + +// optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; +bool SolverParameter::has_solver_type() const { + return (_has_bits_[1] & 0x00000080u) != 0; +} +void SolverParameter::set_has_solver_type() { + _has_bits_[1] |= 0x00000080u; +} +void SolverParameter::clear_has_solver_type() { + _has_bits_[1] &= ~0x00000080u; +} +void SolverParameter::clear_solver_type() { + solver_type_ = 0; + clear_has_solver_type(); +} +::caffe::SolverParameter_SolverType SolverParameter::solver_type() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.solver_type) + return static_cast< ::caffe::SolverParameter_SolverType >(solver_type_); +} +void SolverParameter::set_solver_type(::caffe::SolverParameter_SolverType value) { + assert(::caffe::SolverParameter_SolverType_IsValid(value)); + set_has_solver_type(); + solver_type_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.solver_type) +} + +inline const SolverParameter* SolverParameter::internal_default_instance() { + return &SolverParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int SolverState::kIterFieldNumber; +const int SolverState::kLearnedNetFieldNumber; +const int SolverState::kHistoryFieldNumber; +const int SolverState::kCurrentStepFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +SolverState::SolverState() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.SolverState) +} + +void SolverState::InitAsDefaultInstance() { +} + +SolverState::SolverState(const SolverState& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.SolverState) +} + +void SolverState::SharedCtor() { + _cached_size_ = 0; + learned_net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&iter_, 0, reinterpret_cast(¤t_step_) - + reinterpret_cast(&iter_) + sizeof(current_step_)); +} + +SolverState::~SolverState() { + // @@protoc_insertion_point(destructor:caffe.SolverState) + SharedDtor(); +} + +void SolverState::SharedDtor() { + learned_net_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void SolverState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SolverState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SolverState_descriptor_; +} + +const SolverState& SolverState::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed SolverState_default_instance_; + +SolverState* SolverState::New(::google::protobuf::Arena* arena) const { + SolverState* n = new SolverState; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void SolverState::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.SolverState) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(SolverState, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 11u) { + ZR_(iter_, current_step_); + if (has_learned_net()) { + learned_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + history_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool SolverState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.SolverState) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 iter = 1; + case 1: { + if (tag == 8) { + set_has_iter(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &iter_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_learned_net; + break; + } + + // optional string learned_net = 2; + case 2: { + if (tag == 18) { + parse_learned_net: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_learned_net())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->learned_net().data(), this->learned_net().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SolverState.learned_net"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_history; + break; + } + + // repeated .caffe.BlobProto history = 3; + case 3: { + if (tag == 26) { + parse_history: + DO_(input->IncrementRecursionDepth()); + parse_loop_history: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_history())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_loop_history; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(32)) goto parse_current_step; + break; + } + + // optional int32 current_step = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_current_step: + set_has_current_step(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, ¤t_step_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.SolverState) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.SolverState) + return false; +#undef DO_ +} + +void SolverState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.SolverState) + // optional int32 iter = 1; + if (has_iter()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->iter(), output); + } + + // optional string learned_net = 2; + if (has_learned_net()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->learned_net().data(), this->learned_net().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverState.learned_net"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->learned_net(), output); + } + + // repeated .caffe.BlobProto history = 3; + for (unsigned int i = 0, n = this->history_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->history(i), output); + } + + // optional int32 current_step = 4 [default = 0]; + if (has_current_step()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->current_step(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.SolverState) +} + +::google::protobuf::uint8* SolverState::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.SolverState) + // optional int32 iter = 1; + if (has_iter()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->iter(), target); + } + + // optional string learned_net = 2; + if (has_learned_net()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->learned_net().data(), this->learned_net().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SolverState.learned_net"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->learned_net(), target); + } + + // repeated .caffe.BlobProto history = 3; + for (unsigned int i = 0, n = this->history_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 3, this->history(i), false, target); + } + + // optional int32 current_step = 4 [default = 0]; + if (has_current_step()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->current_step(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.SolverState) + return target; +} + +size_t SolverState::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.SolverState) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 11u) { + // optional int32 iter = 1; + if (has_iter()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->iter()); + } + + // optional string learned_net = 2; + if (has_learned_net()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->learned_net()); + } + + // optional int32 current_step = 4 [default = 0]; + if (has_current_step()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->current_step()); + } + + } + // repeated .caffe.BlobProto history = 3; + { + unsigned int count = this->history_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->history(i)); + } + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SolverState::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.SolverState) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const SolverState* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.SolverState) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.SolverState) + UnsafeMergeFrom(*source); + } +} + +void SolverState::MergeFrom(const SolverState& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.SolverState) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void SolverState::UnsafeMergeFrom(const SolverState& from) { + GOOGLE_DCHECK(&from != this); + history_.MergeFrom(from.history_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_iter()) { + set_iter(from.iter()); + } + if (from.has_learned_net()) { + set_has_learned_net(); + learned_net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.learned_net_); + } + if (from.has_current_step()) { + set_current_step(from.current_step()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void SolverState::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.SolverState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SolverState::CopyFrom(const SolverState& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.SolverState) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool SolverState::IsInitialized() const { + + return true; +} + +void SolverState::Swap(SolverState* other) { + if (other == this) return; + InternalSwap(other); +} +void SolverState::InternalSwap(SolverState* other) { + std::swap(iter_, other->iter_); + learned_net_.Swap(&other->learned_net_); + history_.UnsafeArenaSwap(&other->history_); + std::swap(current_step_, other->current_step_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata SolverState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SolverState_descriptor_; + metadata.reflection = SolverState_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// SolverState + +// optional int32 iter = 1; +bool SolverState::has_iter() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void SolverState::set_has_iter() { + _has_bits_[0] |= 0x00000001u; +} +void SolverState::clear_has_iter() { + _has_bits_[0] &= ~0x00000001u; +} +void SolverState::clear_iter() { + iter_ = 0; + clear_has_iter(); +} +::google::protobuf::int32 SolverState::iter() const { + // @@protoc_insertion_point(field_get:caffe.SolverState.iter) + return iter_; +} +void SolverState::set_iter(::google::protobuf::int32 value) { + set_has_iter(); + iter_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverState.iter) +} + +// optional string learned_net = 2; +bool SolverState::has_learned_net() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void SolverState::set_has_learned_net() { + _has_bits_[0] |= 0x00000002u; +} +void SolverState::clear_has_learned_net() { + _has_bits_[0] &= ~0x00000002u; +} +void SolverState::clear_learned_net() { + learned_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_learned_net(); +} +const ::std::string& SolverState::learned_net() const { + // @@protoc_insertion_point(field_get:caffe.SolverState.learned_net) + return learned_net_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverState::set_learned_net(const ::std::string& value) { + set_has_learned_net(); + learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverState.learned_net) +} +void SolverState::set_learned_net(const char* value) { + set_has_learned_net(); + learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverState.learned_net) +} +void SolverState::set_learned_net(const char* value, size_t size) { + set_has_learned_net(); + learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverState.learned_net) +} +::std::string* SolverState::mutable_learned_net() { + set_has_learned_net(); + // @@protoc_insertion_point(field_mutable:caffe.SolverState.learned_net) + return learned_net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SolverState::release_learned_net() { + // @@protoc_insertion_point(field_release:caffe.SolverState.learned_net) + clear_has_learned_net(); + return learned_net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SolverState::set_allocated_learned_net(::std::string* learned_net) { + if (learned_net != NULL) { + set_has_learned_net(); + } else { + clear_has_learned_net(); + } + learned_net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), learned_net); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverState.learned_net) +} + +// repeated .caffe.BlobProto history = 3; +int SolverState::history_size() const { + return history_.size(); +} +void SolverState::clear_history() { + history_.Clear(); +} +const ::caffe::BlobProto& SolverState::history(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverState.history) + return history_.Get(index); +} +::caffe::BlobProto* SolverState::mutable_history(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverState.history) + return history_.Mutable(index); +} +::caffe::BlobProto* SolverState::add_history() { + // @@protoc_insertion_point(field_add:caffe.SolverState.history) + return history_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +SolverState::mutable_history() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverState.history) + return &history_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +SolverState::history() const { + // @@protoc_insertion_point(field_list:caffe.SolverState.history) + return history_; +} + +// optional int32 current_step = 4 [default = 0]; +bool SolverState::has_current_step() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void SolverState::set_has_current_step() { + _has_bits_[0] |= 0x00000008u; +} +void SolverState::clear_has_current_step() { + _has_bits_[0] &= ~0x00000008u; +} +void SolverState::clear_current_step() { + current_step_ = 0; + clear_has_current_step(); +} +::google::protobuf::int32 SolverState::current_step() const { + // @@protoc_insertion_point(field_get:caffe.SolverState.current_step) + return current_step_; +} +void SolverState::set_current_step(::google::protobuf::int32 value) { + set_has_current_step(); + current_step_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverState.current_step) +} + +inline const SolverState* SolverState::internal_default_instance() { + return &SolverState_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NetState::kPhaseFieldNumber; +const int NetState::kLevelFieldNumber; +const int NetState::kStageFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NetState::NetState() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.NetState) +} + +void NetState::InitAsDefaultInstance() { +} + +NetState::NetState(const NetState& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.NetState) +} + +void NetState::SharedCtor() { + _cached_size_ = 0; + level_ = 0; + phase_ = 1; +} + +NetState::~NetState() { + // @@protoc_insertion_point(destructor:caffe.NetState) + SharedDtor(); +} + +void NetState::SharedDtor() { +} + +void NetState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NetState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NetState_descriptor_; +} + +const NetState& NetState::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NetState_default_instance_; + +NetState* NetState::New(::google::protobuf::Arena* arena) const { + NetState* n = new NetState; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void NetState::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.NetState) + if (_has_bits_[0 / 32] & 3u) { + phase_ = 1; + level_ = 0; + } + stage_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool NetState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.NetState) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.Phase phase = 1 [default = TEST]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::Phase_IsValid(value)) { + set_phase(static_cast< ::caffe::Phase >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_level; + break; + } + + // optional int32 level = 2 [default = 0]; + case 2: { + if (tag == 16) { + parse_level: + set_has_level(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &level_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_stage; + break; + } + + // repeated string stage = 3; + case 3: { + if (tag == 26) { + parse_stage: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_stage())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->stage(this->stage_size() - 1).data(), + this->stage(this->stage_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.NetState.stage"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_stage; + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.NetState) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.NetState) + return false; +#undef DO_ +} + +void NetState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.NetState) + // optional .caffe.Phase phase = 1 [default = TEST]; + if (has_phase()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->phase(), output); + } + + // optional int32 level = 2 [default = 0]; + if (has_level()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->level(), output); + } + + // repeated string stage = 3; + for (int i = 0; i < this->stage_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->stage(i).data(), this->stage(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetState.stage"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->stage(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.NetState) +} + +::google::protobuf::uint8* NetState::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.NetState) + // optional .caffe.Phase phase = 1 [default = TEST]; + if (has_phase()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->phase(), target); + } + + // optional int32 level = 2 [default = 0]; + if (has_level()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->level(), target); + } + + // repeated string stage = 3; + for (int i = 0; i < this->stage_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->stage(i).data(), this->stage(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetState.stage"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->stage(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.NetState) + return target; +} + +size_t NetState::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.NetState) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional .caffe.Phase phase = 1 [default = TEST]; + if (has_phase()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->phase()); + } + + // optional int32 level = 2 [default = 0]; + if (has_level()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->level()); + } + + } + // repeated string stage = 3; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->stage_size()); + for (int i = 0; i < this->stage_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->stage(i)); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NetState::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.NetState) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NetState* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.NetState) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.NetState) + UnsafeMergeFrom(*source); + } +} + +void NetState::MergeFrom(const NetState& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.NetState) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NetState::UnsafeMergeFrom(const NetState& from) { + GOOGLE_DCHECK(&from != this); + stage_.UnsafeMergeFrom(from.stage_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_phase()) { + set_phase(from.phase()); + } + if (from.has_level()) { + set_level(from.level()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void NetState::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.NetState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NetState::CopyFrom(const NetState& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.NetState) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NetState::IsInitialized() const { + + return true; +} + +void NetState::Swap(NetState* other) { + if (other == this) return; + InternalSwap(other); +} +void NetState::InternalSwap(NetState* other) { + std::swap(phase_, other->phase_); + std::swap(level_, other->level_); + stage_.UnsafeArenaSwap(&other->stage_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NetState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NetState_descriptor_; + metadata.reflection = NetState_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NetState + +// optional .caffe.Phase phase = 1 [default = TEST]; +bool NetState::has_phase() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void NetState::set_has_phase() { + _has_bits_[0] |= 0x00000001u; +} +void NetState::clear_has_phase() { + _has_bits_[0] &= ~0x00000001u; +} +void NetState::clear_phase() { + phase_ = 1; + clear_has_phase(); +} +::caffe::Phase NetState::phase() const { + // @@protoc_insertion_point(field_get:caffe.NetState.phase) + return static_cast< ::caffe::Phase >(phase_); +} +void NetState::set_phase(::caffe::Phase value) { + assert(::caffe::Phase_IsValid(value)); + set_has_phase(); + phase_ = value; + // @@protoc_insertion_point(field_set:caffe.NetState.phase) +} + +// optional int32 level = 2 [default = 0]; +bool NetState::has_level() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void NetState::set_has_level() { + _has_bits_[0] |= 0x00000002u; +} +void NetState::clear_has_level() { + _has_bits_[0] &= ~0x00000002u; +} +void NetState::clear_level() { + level_ = 0; + clear_has_level(); +} +::google::protobuf::int32 NetState::level() const { + // @@protoc_insertion_point(field_get:caffe.NetState.level) + return level_; +} +void NetState::set_level(::google::protobuf::int32 value) { + set_has_level(); + level_ = value; + // @@protoc_insertion_point(field_set:caffe.NetState.level) +} + +// repeated string stage = 3; +int NetState::stage_size() const { + return stage_.size(); +} +void NetState::clear_stage() { + stage_.Clear(); +} +const ::std::string& NetState::stage(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetState.stage) + return stage_.Get(index); +} +::std::string* NetState::mutable_stage(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetState.stage) + return stage_.Mutable(index); +} +void NetState::set_stage(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetState.stage) + stage_.Mutable(index)->assign(value); +} +void NetState::set_stage(int index, const char* value) { + stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetState.stage) +} +void NetState::set_stage(int index, const char* value, size_t size) { + stage_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetState.stage) +} +::std::string* NetState::add_stage() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetState.stage) + return stage_.Add(); +} +void NetState::add_stage(const ::std::string& value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetState.stage) +} +void NetState::add_stage(const char* value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetState.stage) +} +void NetState::add_stage(const char* value, size_t size) { + stage_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetState.stage) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetState::stage() const { + // @@protoc_insertion_point(field_list:caffe.NetState.stage) + return stage_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +NetState::mutable_stage() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetState.stage) + return &stage_; +} + +inline const NetState* NetState::internal_default_instance() { + return &NetState_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NetStateRule::kPhaseFieldNumber; +const int NetStateRule::kMinLevelFieldNumber; +const int NetStateRule::kMaxLevelFieldNumber; +const int NetStateRule::kStageFieldNumber; +const int NetStateRule::kNotStageFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NetStateRule::NetStateRule() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.NetStateRule) +} + +void NetStateRule::InitAsDefaultInstance() { +} + +NetStateRule::NetStateRule(const NetStateRule& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.NetStateRule) +} + +void NetStateRule::SharedCtor() { + _cached_size_ = 0; + ::memset(&phase_, 0, reinterpret_cast(&max_level_) - + reinterpret_cast(&phase_) + sizeof(max_level_)); +} + +NetStateRule::~NetStateRule() { + // @@protoc_insertion_point(destructor:caffe.NetStateRule) + SharedDtor(); +} + +void NetStateRule::SharedDtor() { +} + +void NetStateRule::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NetStateRule::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NetStateRule_descriptor_; +} + +const NetStateRule& NetStateRule::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NetStateRule_default_instance_; + +NetStateRule* NetStateRule::New(::google::protobuf::Arena* arena) const { + NetStateRule* n = new NetStateRule; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void NetStateRule::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.NetStateRule) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(NetStateRule, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(phase_, max_level_); + +#undef ZR_HELPER_ +#undef ZR_ + + stage_.Clear(); + not_stage_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool NetStateRule::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.NetStateRule) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.Phase phase = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::Phase_IsValid(value)) { + set_phase(static_cast< ::caffe::Phase >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_min_level; + break; + } + + // optional int32 min_level = 2; + case 2: { + if (tag == 16) { + parse_min_level: + set_has_min_level(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &min_level_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_max_level; + break; + } + + // optional int32 max_level = 3; + case 3: { + if (tag == 24) { + parse_max_level: + set_has_max_level(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &max_level_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_stage; + break; + } + + // repeated string stage = 4; + case 4: { + if (tag == 34) { + parse_stage: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_stage())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->stage(this->stage_size() - 1).data(), + this->stage(this->stage_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.NetStateRule.stage"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_stage; + if (input->ExpectTag(42)) goto parse_not_stage; + break; + } + + // repeated string not_stage = 5; + case 5: { + if (tag == 42) { + parse_not_stage: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_not_stage())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->not_stage(this->not_stage_size() - 1).data(), + this->not_stage(this->not_stage_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.NetStateRule.not_stage"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_not_stage; + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.NetStateRule) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.NetStateRule) + return false; +#undef DO_ +} + +void NetStateRule::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.NetStateRule) + // optional .caffe.Phase phase = 1; + if (has_phase()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->phase(), output); + } + + // optional int32 min_level = 2; + if (has_min_level()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->min_level(), output); + } + + // optional int32 max_level = 3; + if (has_max_level()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->max_level(), output); + } + + // repeated string stage = 4; + for (int i = 0; i < this->stage_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->stage(i).data(), this->stage(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetStateRule.stage"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->stage(i), output); + } + + // repeated string not_stage = 5; + for (int i = 0; i < this->not_stage_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->not_stage(i).data(), this->not_stage(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetStateRule.not_stage"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 5, this->not_stage(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.NetStateRule) +} + +::google::protobuf::uint8* NetStateRule::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.NetStateRule) + // optional .caffe.Phase phase = 1; + if (has_phase()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->phase(), target); + } + + // optional int32 min_level = 2; + if (has_min_level()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->min_level(), target); + } + + // optional int32 max_level = 3; + if (has_max_level()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->max_level(), target); + } + + // repeated string stage = 4; + for (int i = 0; i < this->stage_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->stage(i).data(), this->stage(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetStateRule.stage"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(4, this->stage(i), target); + } + + // repeated string not_stage = 5; + for (int i = 0; i < this->not_stage_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->not_stage(i).data(), this->not_stage(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.NetStateRule.not_stage"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(5, this->not_stage(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.NetStateRule) + return target; +} + +size_t NetStateRule::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.NetStateRule) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional .caffe.Phase phase = 1; + if (has_phase()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->phase()); + } + + // optional int32 min_level = 2; + if (has_min_level()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->min_level()); + } + + // optional int32 max_level = 3; + if (has_max_level()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->max_level()); + } + + } + // repeated string stage = 4; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->stage_size()); + for (int i = 0; i < this->stage_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->stage(i)); + } + + // repeated string not_stage = 5; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->not_stage_size()); + for (int i = 0; i < this->not_stage_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->not_stage(i)); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NetStateRule::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.NetStateRule) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NetStateRule* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.NetStateRule) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.NetStateRule) + UnsafeMergeFrom(*source); + } +} + +void NetStateRule::MergeFrom(const NetStateRule& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.NetStateRule) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NetStateRule::UnsafeMergeFrom(const NetStateRule& from) { + GOOGLE_DCHECK(&from != this); + stage_.UnsafeMergeFrom(from.stage_); + not_stage_.UnsafeMergeFrom(from.not_stage_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_phase()) { + set_phase(from.phase()); + } + if (from.has_min_level()) { + set_min_level(from.min_level()); + } + if (from.has_max_level()) { + set_max_level(from.max_level()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void NetStateRule::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.NetStateRule) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NetStateRule::CopyFrom(const NetStateRule& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.NetStateRule) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NetStateRule::IsInitialized() const { + + return true; +} + +void NetStateRule::Swap(NetStateRule* other) { + if (other == this) return; + InternalSwap(other); +} +void NetStateRule::InternalSwap(NetStateRule* other) { + std::swap(phase_, other->phase_); + std::swap(min_level_, other->min_level_); + std::swap(max_level_, other->max_level_); + stage_.UnsafeArenaSwap(&other->stage_); + not_stage_.UnsafeArenaSwap(&other->not_stage_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NetStateRule::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NetStateRule_descriptor_; + metadata.reflection = NetStateRule_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NetStateRule + +// optional .caffe.Phase phase = 1; +bool NetStateRule::has_phase() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void NetStateRule::set_has_phase() { + _has_bits_[0] |= 0x00000001u; +} +void NetStateRule::clear_has_phase() { + _has_bits_[0] &= ~0x00000001u; +} +void NetStateRule::clear_phase() { + phase_ = 0; + clear_has_phase(); +} +::caffe::Phase NetStateRule::phase() const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.phase) + return static_cast< ::caffe::Phase >(phase_); +} +void NetStateRule::set_phase(::caffe::Phase value) { + assert(::caffe::Phase_IsValid(value)); + set_has_phase(); + phase_ = value; + // @@protoc_insertion_point(field_set:caffe.NetStateRule.phase) +} + +// optional int32 min_level = 2; +bool NetStateRule::has_min_level() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void NetStateRule::set_has_min_level() { + _has_bits_[0] |= 0x00000002u; +} +void NetStateRule::clear_has_min_level() { + _has_bits_[0] &= ~0x00000002u; +} +void NetStateRule::clear_min_level() { + min_level_ = 0; + clear_has_min_level(); +} +::google::protobuf::int32 NetStateRule::min_level() const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.min_level) + return min_level_; +} +void NetStateRule::set_min_level(::google::protobuf::int32 value) { + set_has_min_level(); + min_level_ = value; + // @@protoc_insertion_point(field_set:caffe.NetStateRule.min_level) +} + +// optional int32 max_level = 3; +bool NetStateRule::has_max_level() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void NetStateRule::set_has_max_level() { + _has_bits_[0] |= 0x00000004u; +} +void NetStateRule::clear_has_max_level() { + _has_bits_[0] &= ~0x00000004u; +} +void NetStateRule::clear_max_level() { + max_level_ = 0; + clear_has_max_level(); +} +::google::protobuf::int32 NetStateRule::max_level() const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.max_level) + return max_level_; +} +void NetStateRule::set_max_level(::google::protobuf::int32 value) { + set_has_max_level(); + max_level_ = value; + // @@protoc_insertion_point(field_set:caffe.NetStateRule.max_level) +} + +// repeated string stage = 4; +int NetStateRule::stage_size() const { + return stage_.size(); +} +void NetStateRule::clear_stage() { + stage_.Clear(); +} +const ::std::string& NetStateRule::stage(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.stage) + return stage_.Get(index); +} +::std::string* NetStateRule::mutable_stage(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetStateRule.stage) + return stage_.Mutable(index); +} +void NetStateRule::set_stage(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetStateRule.stage) + stage_.Mutable(index)->assign(value); +} +void NetStateRule::set_stage(int index, const char* value) { + stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetStateRule.stage) +} +void NetStateRule::set_stage(int index, const char* value, size_t size) { + stage_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetStateRule.stage) +} +::std::string* NetStateRule::add_stage() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetStateRule.stage) + return stage_.Add(); +} +void NetStateRule::add_stage(const ::std::string& value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetStateRule.stage) +} +void NetStateRule::add_stage(const char* value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetStateRule.stage) +} +void NetStateRule::add_stage(const char* value, size_t size) { + stage_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.stage) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetStateRule::stage() const { + // @@protoc_insertion_point(field_list:caffe.NetStateRule.stage) + return stage_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +NetStateRule::mutable_stage() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetStateRule.stage) + return &stage_; +} + +// repeated string not_stage = 5; +int NetStateRule::not_stage_size() const { + return not_stage_.size(); +} +void NetStateRule::clear_not_stage() { + not_stage_.Clear(); +} +const ::std::string& NetStateRule::not_stage(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.not_stage) + return not_stage_.Get(index); +} +::std::string* NetStateRule::mutable_not_stage(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetStateRule.not_stage) + return not_stage_.Mutable(index); +} +void NetStateRule::set_not_stage(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetStateRule.not_stage) + not_stage_.Mutable(index)->assign(value); +} +void NetStateRule::set_not_stage(int index, const char* value) { + not_stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetStateRule.not_stage) +} +void NetStateRule::set_not_stage(int index, const char* value, size_t size) { + not_stage_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetStateRule.not_stage) +} +::std::string* NetStateRule::add_not_stage() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetStateRule.not_stage) + return not_stage_.Add(); +} +void NetStateRule::add_not_stage(const ::std::string& value) { + not_stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetStateRule.not_stage) +} +void NetStateRule::add_not_stage(const char* value) { + not_stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetStateRule.not_stage) +} +void NetStateRule::add_not_stage(const char* value, size_t size) { + not_stage_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.not_stage) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetStateRule::not_stage() const { + // @@protoc_insertion_point(field_list:caffe.NetStateRule.not_stage) + return not_stage_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +NetStateRule::mutable_not_stage() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetStateRule.not_stage) + return ¬_stage_; +} + +inline const NetStateRule* NetStateRule::internal_default_instance() { + return &NetStateRule_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* ParamSpec_DimCheckMode_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ParamSpec_DimCheckMode_descriptor_; +} +bool ParamSpec_DimCheckMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const ParamSpec_DimCheckMode ParamSpec::STRICT; +const ParamSpec_DimCheckMode ParamSpec::PERMISSIVE; +const ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MIN; +const ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MAX; +const int ParamSpec::DimCheckMode_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ParamSpec::kNameFieldNumber; +const int ParamSpec::kShareModeFieldNumber; +const int ParamSpec::kLrMultFieldNumber; +const int ParamSpec::kDecayMultFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ParamSpec::ParamSpec() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ParamSpec) +} + +void ParamSpec::InitAsDefaultInstance() { +} + +ParamSpec::ParamSpec(const ParamSpec& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ParamSpec) +} + +void ParamSpec::SharedCtor() { + _cached_size_ = 0; + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + share_mode_ = 0; + lr_mult_ = 1; + decay_mult_ = 1; +} + +ParamSpec::~ParamSpec() { + // @@protoc_insertion_point(destructor:caffe.ParamSpec) + SharedDtor(); +} + +void ParamSpec::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void ParamSpec::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ParamSpec::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ParamSpec_descriptor_; +} + +const ParamSpec& ParamSpec::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ParamSpec_default_instance_; + +ParamSpec* ParamSpec::New(::google::protobuf::Arena* arena) const { + ParamSpec* n = new ParamSpec; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ParamSpec::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ParamSpec) + if (_has_bits_[0 / 32] & 15u) { + if (has_name()) { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + share_mode_ = 0; + lr_mult_ = 1; + decay_mult_ = 1; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ParamSpec::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ParamSpec) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.ParamSpec.name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_share_mode; + break; + } + + // optional .caffe.ParamSpec.DimCheckMode share_mode = 2; + case 2: { + if (tag == 16) { + parse_share_mode: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::ParamSpec_DimCheckMode_IsValid(value)) { + set_share_mode(static_cast< ::caffe::ParamSpec_DimCheckMode >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_lr_mult; + break; + } + + // optional float lr_mult = 3 [default = 1]; + case 3: { + if (tag == 29) { + parse_lr_mult: + set_has_lr_mult(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &lr_mult_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_decay_mult; + break; + } + + // optional float decay_mult = 4 [default = 1]; + case 4: { + if (tag == 37) { + parse_decay_mult: + set_has_decay_mult(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &decay_mult_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ParamSpec) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ParamSpec) + return false; +#undef DO_ +} + +void ParamSpec::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ParamSpec) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ParamSpec.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional .caffe.ParamSpec.DimCheckMode share_mode = 2; + if (has_share_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->share_mode(), output); + } + + // optional float lr_mult = 3 [default = 1]; + if (has_lr_mult()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->lr_mult(), output); + } + + // optional float decay_mult = 4 [default = 1]; + if (has_decay_mult()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->decay_mult(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ParamSpec) +} + +::google::protobuf::uint8* ParamSpec::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ParamSpec) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ParamSpec.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional .caffe.ParamSpec.DimCheckMode share_mode = 2; + if (has_share_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->share_mode(), target); + } + + // optional float lr_mult = 3 [default = 1]; + if (has_lr_mult()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->lr_mult(), target); + } + + // optional float decay_mult = 4 [default = 1]; + if (has_decay_mult()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->decay_mult(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ParamSpec) + return target; +} + +size_t ParamSpec::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ParamSpec) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 15u) { + // optional string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional .caffe.ParamSpec.DimCheckMode share_mode = 2; + if (has_share_mode()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->share_mode()); + } + + // optional float lr_mult = 3 [default = 1]; + if (has_lr_mult()) { + total_size += 1 + 4; + } + + // optional float decay_mult = 4 [default = 1]; + if (has_decay_mult()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ParamSpec::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ParamSpec) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ParamSpec* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ParamSpec) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ParamSpec) + UnsafeMergeFrom(*source); + } +} + +void ParamSpec::MergeFrom(const ParamSpec& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ParamSpec) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ParamSpec::UnsafeMergeFrom(const ParamSpec& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_share_mode()) { + set_share_mode(from.share_mode()); + } + if (from.has_lr_mult()) { + set_lr_mult(from.lr_mult()); + } + if (from.has_decay_mult()) { + set_decay_mult(from.decay_mult()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ParamSpec::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ParamSpec) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParamSpec::CopyFrom(const ParamSpec& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ParamSpec) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ParamSpec::IsInitialized() const { + + return true; +} + +void ParamSpec::Swap(ParamSpec* other) { + if (other == this) return; + InternalSwap(other); +} +void ParamSpec::InternalSwap(ParamSpec* other) { + name_.Swap(&other->name_); + std::swap(share_mode_, other->share_mode_); + std::swap(lr_mult_, other->lr_mult_); + std::swap(decay_mult_, other->decay_mult_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ParamSpec::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ParamSpec_descriptor_; + metadata.reflection = ParamSpec_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ParamSpec + +// optional string name = 1; +bool ParamSpec::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ParamSpec::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +void ParamSpec::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +void ParamSpec::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +const ::std::string& ParamSpec::name() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ParamSpec::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ParamSpec.name) +} +void ParamSpec::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ParamSpec.name) +} +void ParamSpec::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ParamSpec.name) +} +::std::string* ParamSpec::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.ParamSpec.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* ParamSpec::release_name() { + // @@protoc_insertion_point(field_release:caffe.ParamSpec.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ParamSpec::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.ParamSpec.name) +} + +// optional .caffe.ParamSpec.DimCheckMode share_mode = 2; +bool ParamSpec::has_share_mode() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ParamSpec::set_has_share_mode() { + _has_bits_[0] |= 0x00000002u; +} +void ParamSpec::clear_has_share_mode() { + _has_bits_[0] &= ~0x00000002u; +} +void ParamSpec::clear_share_mode() { + share_mode_ = 0; + clear_has_share_mode(); +} +::caffe::ParamSpec_DimCheckMode ParamSpec::share_mode() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.share_mode) + return static_cast< ::caffe::ParamSpec_DimCheckMode >(share_mode_); +} +void ParamSpec::set_share_mode(::caffe::ParamSpec_DimCheckMode value) { + assert(::caffe::ParamSpec_DimCheckMode_IsValid(value)); + set_has_share_mode(); + share_mode_ = value; + // @@protoc_insertion_point(field_set:caffe.ParamSpec.share_mode) +} + +// optional float lr_mult = 3 [default = 1]; +bool ParamSpec::has_lr_mult() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void ParamSpec::set_has_lr_mult() { + _has_bits_[0] |= 0x00000004u; +} +void ParamSpec::clear_has_lr_mult() { + _has_bits_[0] &= ~0x00000004u; +} +void ParamSpec::clear_lr_mult() { + lr_mult_ = 1; + clear_has_lr_mult(); +} +float ParamSpec::lr_mult() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.lr_mult) + return lr_mult_; +} +void ParamSpec::set_lr_mult(float value) { + set_has_lr_mult(); + lr_mult_ = value; + // @@protoc_insertion_point(field_set:caffe.ParamSpec.lr_mult) +} + +// optional float decay_mult = 4 [default = 1]; +bool ParamSpec::has_decay_mult() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void ParamSpec::set_has_decay_mult() { + _has_bits_[0] |= 0x00000008u; +} +void ParamSpec::clear_has_decay_mult() { + _has_bits_[0] &= ~0x00000008u; +} +void ParamSpec::clear_decay_mult() { + decay_mult_ = 1; + clear_has_decay_mult(); +} +float ParamSpec::decay_mult() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.decay_mult) + return decay_mult_; +} +void ParamSpec::set_decay_mult(float value) { + set_has_decay_mult(); + decay_mult_ = value; + // @@protoc_insertion_point(field_set:caffe.ParamSpec.decay_mult) +} + +inline const ParamSpec* ParamSpec::internal_default_instance() { + return &ParamSpec_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int LayerParameter::kNameFieldNumber; +const int LayerParameter::kTypeFieldNumber; +const int LayerParameter::kBottomFieldNumber; +const int LayerParameter::kTopFieldNumber; +const int LayerParameter::kPhaseFieldNumber; +const int LayerParameter::kLossWeightFieldNumber; +const int LayerParameter::kParamFieldNumber; +const int LayerParameter::kBlobsFieldNumber; +const int LayerParameter::kPropagateDownFieldNumber; +const int LayerParameter::kIncludeFieldNumber; +const int LayerParameter::kExcludeFieldNumber; +const int LayerParameter::kTransformParamFieldNumber; +const int LayerParameter::kLossParamFieldNumber; +const int LayerParameter::kAccuracyParamFieldNumber; +const int LayerParameter::kArgmaxParamFieldNumber; +const int LayerParameter::kBatchNormParamFieldNumber; +const int LayerParameter::kBiasParamFieldNumber; +const int LayerParameter::kConcatParamFieldNumber; +const int LayerParameter::kContrastiveLossParamFieldNumber; +const int LayerParameter::kConvolutionParamFieldNumber; +const int LayerParameter::kCropParamFieldNumber; +const int LayerParameter::kDataParamFieldNumber; +const int LayerParameter::kDetectionOutputParamFieldNumber; +const int LayerParameter::kDropoutParamFieldNumber; +const int LayerParameter::kDummyDataParamFieldNumber; +const int LayerParameter::kEltwiseParamFieldNumber; +const int LayerParameter::kEluParamFieldNumber; +const int LayerParameter::kEmbedParamFieldNumber; +const int LayerParameter::kExpParamFieldNumber; +const int LayerParameter::kFlattenParamFieldNumber; +const int LayerParameter::kHdf5DataParamFieldNumber; +const int LayerParameter::kHdf5OutputParamFieldNumber; +const int LayerParameter::kHingeLossParamFieldNumber; +const int LayerParameter::kImageDataParamFieldNumber; +const int LayerParameter::kInfogainLossParamFieldNumber; +const int LayerParameter::kInnerProductParamFieldNumber; +const int LayerParameter::kInputParamFieldNumber; +const int LayerParameter::kLogParamFieldNumber; +const int LayerParameter::kLrnParamFieldNumber; +const int LayerParameter::kMemoryDataParamFieldNumber; +const int LayerParameter::kMvnParamFieldNumber; +const int LayerParameter::kNormParamFieldNumber; +const int LayerParameter::kPermuteParamFieldNumber; +const int LayerParameter::kParameterParamFieldNumber; +const int LayerParameter::kPoolingParamFieldNumber; +const int LayerParameter::kPowerParamFieldNumber; +const int LayerParameter::kPreluParamFieldNumber; +const int LayerParameter::kPriorBoxParamFieldNumber; +const int LayerParameter::kPythonParamFieldNumber; +const int LayerParameter::kRecurrentParamFieldNumber; +const int LayerParameter::kReductionParamFieldNumber; +const int LayerParameter::kReluParamFieldNumber; +const int LayerParameter::kReshapeParamFieldNumber; +const int LayerParameter::kScaleParamFieldNumber; +const int LayerParameter::kSigmoidParamFieldNumber; +const int LayerParameter::kSoftmaxParamFieldNumber; +const int LayerParameter::kSppParamFieldNumber; +const int LayerParameter::kSliceParamFieldNumber; +const int LayerParameter::kTanhParamFieldNumber; +const int LayerParameter::kThresholdParamFieldNumber; +const int LayerParameter::kTileParamFieldNumber; +const int LayerParameter::kWindowDataParamFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +LayerParameter::LayerParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.LayerParameter) +} + +void LayerParameter::InitAsDefaultInstance() { + transform_param_ = const_cast< ::caffe::TransformationParameter*>( + ::caffe::TransformationParameter::internal_default_instance()); + loss_param_ = const_cast< ::caffe::LossParameter*>( + ::caffe::LossParameter::internal_default_instance()); + accuracy_param_ = const_cast< ::caffe::AccuracyParameter*>( + ::caffe::AccuracyParameter::internal_default_instance()); + argmax_param_ = const_cast< ::caffe::ArgMaxParameter*>( + ::caffe::ArgMaxParameter::internal_default_instance()); + batch_norm_param_ = const_cast< ::caffe::BatchNormParameter*>( + ::caffe::BatchNormParameter::internal_default_instance()); + bias_param_ = const_cast< ::caffe::BiasParameter*>( + ::caffe::BiasParameter::internal_default_instance()); + concat_param_ = const_cast< ::caffe::ConcatParameter*>( + ::caffe::ConcatParameter::internal_default_instance()); + contrastive_loss_param_ = const_cast< ::caffe::ContrastiveLossParameter*>( + ::caffe::ContrastiveLossParameter::internal_default_instance()); + convolution_param_ = const_cast< ::caffe::ConvolutionParameter*>( + ::caffe::ConvolutionParameter::internal_default_instance()); + crop_param_ = const_cast< ::caffe::CropParameter*>( + ::caffe::CropParameter::internal_default_instance()); + data_param_ = const_cast< ::caffe::DataParameter*>( + ::caffe::DataParameter::internal_default_instance()); + detection_output_param_ = const_cast< ::caffe::DetectionOutputParameter*>( + ::caffe::DetectionOutputParameter::internal_default_instance()); + dropout_param_ = const_cast< ::caffe::DropoutParameter*>( + ::caffe::DropoutParameter::internal_default_instance()); + dummy_data_param_ = const_cast< ::caffe::DummyDataParameter*>( + ::caffe::DummyDataParameter::internal_default_instance()); + eltwise_param_ = const_cast< ::caffe::EltwiseParameter*>( + ::caffe::EltwiseParameter::internal_default_instance()); + elu_param_ = const_cast< ::caffe::ELUParameter*>( + ::caffe::ELUParameter::internal_default_instance()); + embed_param_ = const_cast< ::caffe::EmbedParameter*>( + ::caffe::EmbedParameter::internal_default_instance()); + exp_param_ = const_cast< ::caffe::ExpParameter*>( + ::caffe::ExpParameter::internal_default_instance()); + flatten_param_ = const_cast< ::caffe::FlattenParameter*>( + ::caffe::FlattenParameter::internal_default_instance()); + hdf5_data_param_ = const_cast< ::caffe::HDF5DataParameter*>( + ::caffe::HDF5DataParameter::internal_default_instance()); + hdf5_output_param_ = const_cast< ::caffe::HDF5OutputParameter*>( + ::caffe::HDF5OutputParameter::internal_default_instance()); + hinge_loss_param_ = const_cast< ::caffe::HingeLossParameter*>( + ::caffe::HingeLossParameter::internal_default_instance()); + image_data_param_ = const_cast< ::caffe::ImageDataParameter*>( + ::caffe::ImageDataParameter::internal_default_instance()); + infogain_loss_param_ = const_cast< ::caffe::InfogainLossParameter*>( + ::caffe::InfogainLossParameter::internal_default_instance()); + inner_product_param_ = const_cast< ::caffe::InnerProductParameter*>( + ::caffe::InnerProductParameter::internal_default_instance()); + input_param_ = const_cast< ::caffe::InputParameter*>( + ::caffe::InputParameter::internal_default_instance()); + log_param_ = const_cast< ::caffe::LogParameter*>( + ::caffe::LogParameter::internal_default_instance()); + lrn_param_ = const_cast< ::caffe::LRNParameter*>( + ::caffe::LRNParameter::internal_default_instance()); + memory_data_param_ = const_cast< ::caffe::MemoryDataParameter*>( + ::caffe::MemoryDataParameter::internal_default_instance()); + mvn_param_ = const_cast< ::caffe::MVNParameter*>( + ::caffe::MVNParameter::internal_default_instance()); + norm_param_ = const_cast< ::caffe::NormalizeBBoxParameter*>( + ::caffe::NormalizeBBoxParameter::internal_default_instance()); + permute_param_ = const_cast< ::caffe::PermuteParameter*>( + ::caffe::PermuteParameter::internal_default_instance()); + parameter_param_ = const_cast< ::caffe::ParameterParameter*>( + ::caffe::ParameterParameter::internal_default_instance()); + pooling_param_ = const_cast< ::caffe::PoolingParameter*>( + ::caffe::PoolingParameter::internal_default_instance()); + power_param_ = const_cast< ::caffe::PowerParameter*>( + ::caffe::PowerParameter::internal_default_instance()); + prelu_param_ = const_cast< ::caffe::PReLUParameter*>( + ::caffe::PReLUParameter::internal_default_instance()); + prior_box_param_ = const_cast< ::caffe::PriorBoxParameter*>( + ::caffe::PriorBoxParameter::internal_default_instance()); + python_param_ = const_cast< ::caffe::PythonParameter*>( + ::caffe::PythonParameter::internal_default_instance()); + recurrent_param_ = const_cast< ::caffe::RecurrentParameter*>( + ::caffe::RecurrentParameter::internal_default_instance()); + reduction_param_ = const_cast< ::caffe::ReductionParameter*>( + ::caffe::ReductionParameter::internal_default_instance()); + relu_param_ = const_cast< ::caffe::ReLUParameter*>( + ::caffe::ReLUParameter::internal_default_instance()); + reshape_param_ = const_cast< ::caffe::ReshapeParameter*>( + ::caffe::ReshapeParameter::internal_default_instance()); + scale_param_ = const_cast< ::caffe::ScaleParameter*>( + ::caffe::ScaleParameter::internal_default_instance()); + sigmoid_param_ = const_cast< ::caffe::SigmoidParameter*>( + ::caffe::SigmoidParameter::internal_default_instance()); + softmax_param_ = const_cast< ::caffe::SoftmaxParameter*>( + ::caffe::SoftmaxParameter::internal_default_instance()); + spp_param_ = const_cast< ::caffe::SPPParameter*>( + ::caffe::SPPParameter::internal_default_instance()); + slice_param_ = const_cast< ::caffe::SliceParameter*>( + ::caffe::SliceParameter::internal_default_instance()); + tanh_param_ = const_cast< ::caffe::TanHParameter*>( + ::caffe::TanHParameter::internal_default_instance()); + threshold_param_ = const_cast< ::caffe::ThresholdParameter*>( + ::caffe::ThresholdParameter::internal_default_instance()); + tile_param_ = const_cast< ::caffe::TileParameter*>( + ::caffe::TileParameter::internal_default_instance()); + window_data_param_ = const_cast< ::caffe::WindowDataParameter*>( + ::caffe::WindowDataParameter::internal_default_instance()); +} + +LayerParameter::LayerParameter(const LayerParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.LayerParameter) +} + +void LayerParameter::SharedCtor() { + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + transform_param_ = NULL; + loss_param_ = NULL; + accuracy_param_ = NULL; + argmax_param_ = NULL; + batch_norm_param_ = NULL; + bias_param_ = NULL; + concat_param_ = NULL; + contrastive_loss_param_ = NULL; + convolution_param_ = NULL; + crop_param_ = NULL; + data_param_ = NULL; + detection_output_param_ = NULL; + dropout_param_ = NULL; + dummy_data_param_ = NULL; + eltwise_param_ = NULL; + elu_param_ = NULL; + embed_param_ = NULL; + exp_param_ = NULL; + flatten_param_ = NULL; + hdf5_data_param_ = NULL; + hdf5_output_param_ = NULL; + hinge_loss_param_ = NULL; + image_data_param_ = NULL; + infogain_loss_param_ = NULL; + inner_product_param_ = NULL; + input_param_ = NULL; + log_param_ = NULL; + lrn_param_ = NULL; + memory_data_param_ = NULL; + mvn_param_ = NULL; + norm_param_ = NULL; + permute_param_ = NULL; + parameter_param_ = NULL; + pooling_param_ = NULL; + power_param_ = NULL; + prelu_param_ = NULL; + prior_box_param_ = NULL; + python_param_ = NULL; + recurrent_param_ = NULL; + reduction_param_ = NULL; + relu_param_ = NULL; + reshape_param_ = NULL; + scale_param_ = NULL; + sigmoid_param_ = NULL; + softmax_param_ = NULL; + spp_param_ = NULL; + slice_param_ = NULL; + tanh_param_ = NULL; + threshold_param_ = NULL; + tile_param_ = NULL; + window_data_param_ = NULL; + phase_ = 0; + _cached_size_ = 0; +} + +LayerParameter::~LayerParameter() { + // @@protoc_insertion_point(destructor:caffe.LayerParameter) + SharedDtor(); +} + +void LayerParameter::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != &LayerParameter_default_instance_.get()) { + delete transform_param_; + delete loss_param_; + delete accuracy_param_; + delete argmax_param_; + delete batch_norm_param_; + delete bias_param_; + delete concat_param_; + delete contrastive_loss_param_; + delete convolution_param_; + delete crop_param_; + delete data_param_; + delete detection_output_param_; + delete dropout_param_; + delete dummy_data_param_; + delete eltwise_param_; + delete elu_param_; + delete embed_param_; + delete exp_param_; + delete flatten_param_; + delete hdf5_data_param_; + delete hdf5_output_param_; + delete hinge_loss_param_; + delete image_data_param_; + delete infogain_loss_param_; + delete inner_product_param_; + delete input_param_; + delete log_param_; + delete lrn_param_; + delete memory_data_param_; + delete mvn_param_; + delete norm_param_; + delete permute_param_; + delete parameter_param_; + delete pooling_param_; + delete power_param_; + delete prelu_param_; + delete prior_box_param_; + delete python_param_; + delete recurrent_param_; + delete reduction_param_; + delete relu_param_; + delete reshape_param_; + delete scale_param_; + delete sigmoid_param_; + delete softmax_param_; + delete spp_param_; + delete slice_param_; + delete tanh_param_; + delete threshold_param_; + delete tile_param_; + delete window_data_param_; + } +} + +void LayerParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LayerParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LayerParameter_descriptor_; +} + +const LayerParameter& LayerParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed LayerParameter_default_instance_; + +LayerParameter* LayerParameter::New(::google::protobuf::Arena* arena) const { + LayerParameter* n = new LayerParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void LayerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.LayerParameter) + if (_has_bits_[0 / 32] & 19u) { + if (has_name()) { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_type()) { + type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + phase_ = 0; + } + if (_has_bits_[8 / 32] & 63488u) { + if (has_transform_param()) { + if (transform_param_ != NULL) transform_param_->::caffe::TransformationParameter::Clear(); + } + if (has_loss_param()) { + if (loss_param_ != NULL) loss_param_->::caffe::LossParameter::Clear(); + } + if (has_accuracy_param()) { + if (accuracy_param_ != NULL) accuracy_param_->::caffe::AccuracyParameter::Clear(); + } + if (has_argmax_param()) { + if (argmax_param_ != NULL) argmax_param_->::caffe::ArgMaxParameter::Clear(); + } + if (has_batch_norm_param()) { + if (batch_norm_param_ != NULL) batch_norm_param_->::caffe::BatchNormParameter::Clear(); + } + } + if (_has_bits_[16 / 32] & 16711680u) { + if (has_bias_param()) { + if (bias_param_ != NULL) bias_param_->::caffe::BiasParameter::Clear(); + } + if (has_concat_param()) { + if (concat_param_ != NULL) concat_param_->::caffe::ConcatParameter::Clear(); + } + if (has_contrastive_loss_param()) { + if (contrastive_loss_param_ != NULL) contrastive_loss_param_->::caffe::ContrastiveLossParameter::Clear(); + } + if (has_convolution_param()) { + if (convolution_param_ != NULL) convolution_param_->::caffe::ConvolutionParameter::Clear(); + } + if (has_crop_param()) { + if (crop_param_ != NULL) crop_param_->::caffe::CropParameter::Clear(); + } + if (has_data_param()) { + if (data_param_ != NULL) data_param_->::caffe::DataParameter::Clear(); + } + if (has_detection_output_param()) { + if (detection_output_param_ != NULL) detection_output_param_->::caffe::DetectionOutputParameter::Clear(); + } + if (has_dropout_param()) { + if (dropout_param_ != NULL) dropout_param_->::caffe::DropoutParameter::Clear(); + } + } + if (_has_bits_[24 / 32] & 4278190080u) { + if (has_dummy_data_param()) { + if (dummy_data_param_ != NULL) dummy_data_param_->::caffe::DummyDataParameter::Clear(); + } + if (has_eltwise_param()) { + if (eltwise_param_ != NULL) eltwise_param_->::caffe::EltwiseParameter::Clear(); + } + if (has_elu_param()) { + if (elu_param_ != NULL) elu_param_->::caffe::ELUParameter::Clear(); + } + if (has_embed_param()) { + if (embed_param_ != NULL) embed_param_->::caffe::EmbedParameter::Clear(); + } + if (has_exp_param()) { + if (exp_param_ != NULL) exp_param_->::caffe::ExpParameter::Clear(); + } + if (has_flatten_param()) { + if (flatten_param_ != NULL) flatten_param_->::caffe::FlattenParameter::Clear(); + } + if (has_hdf5_data_param()) { + if (hdf5_data_param_ != NULL) hdf5_data_param_->::caffe::HDF5DataParameter::Clear(); + } + if (has_hdf5_output_param()) { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + } + } + if (_has_bits_[32 / 32] & 255u) { + if (has_hinge_loss_param()) { + if (hinge_loss_param_ != NULL) hinge_loss_param_->::caffe::HingeLossParameter::Clear(); + } + if (has_image_data_param()) { + if (image_data_param_ != NULL) image_data_param_->::caffe::ImageDataParameter::Clear(); + } + if (has_infogain_loss_param()) { + if (infogain_loss_param_ != NULL) infogain_loss_param_->::caffe::InfogainLossParameter::Clear(); + } + if (has_inner_product_param()) { + if (inner_product_param_ != NULL) inner_product_param_->::caffe::InnerProductParameter::Clear(); + } + if (has_input_param()) { + if (input_param_ != NULL) input_param_->::caffe::InputParameter::Clear(); + } + if (has_log_param()) { + if (log_param_ != NULL) log_param_->::caffe::LogParameter::Clear(); + } + if (has_lrn_param()) { + if (lrn_param_ != NULL) lrn_param_->::caffe::LRNParameter::Clear(); + } + if (has_memory_data_param()) { + if (memory_data_param_ != NULL) memory_data_param_->::caffe::MemoryDataParameter::Clear(); + } + } + if (_has_bits_[40 / 32] & 65280u) { + if (has_mvn_param()) { + if (mvn_param_ != NULL) mvn_param_->::caffe::MVNParameter::Clear(); + } + if (has_norm_param()) { + if (norm_param_ != NULL) norm_param_->::caffe::NormalizeBBoxParameter::Clear(); + } + if (has_permute_param()) { + if (permute_param_ != NULL) permute_param_->::caffe::PermuteParameter::Clear(); + } + if (has_parameter_param()) { + if (parameter_param_ != NULL) parameter_param_->::caffe::ParameterParameter::Clear(); + } + if (has_pooling_param()) { + if (pooling_param_ != NULL) pooling_param_->::caffe::PoolingParameter::Clear(); + } + if (has_power_param()) { + if (power_param_ != NULL) power_param_->::caffe::PowerParameter::Clear(); + } + if (has_prelu_param()) { + if (prelu_param_ != NULL) prelu_param_->::caffe::PReLUParameter::Clear(); + } + if (has_prior_box_param()) { + if (prior_box_param_ != NULL) prior_box_param_->::caffe::PriorBoxParameter::Clear(); + } + } + if (_has_bits_[48 / 32] & 16711680u) { + if (has_python_param()) { + if (python_param_ != NULL) python_param_->::caffe::PythonParameter::Clear(); + } + if (has_recurrent_param()) { + if (recurrent_param_ != NULL) recurrent_param_->::caffe::RecurrentParameter::Clear(); + } + if (has_reduction_param()) { + if (reduction_param_ != NULL) reduction_param_->::caffe::ReductionParameter::Clear(); + } + if (has_relu_param()) { + if (relu_param_ != NULL) relu_param_->::caffe::ReLUParameter::Clear(); + } + if (has_reshape_param()) { + if (reshape_param_ != NULL) reshape_param_->::caffe::ReshapeParameter::Clear(); + } + if (has_scale_param()) { + if (scale_param_ != NULL) scale_param_->::caffe::ScaleParameter::Clear(); + } + if (has_sigmoid_param()) { + if (sigmoid_param_ != NULL) sigmoid_param_->::caffe::SigmoidParameter::Clear(); + } + if (has_softmax_param()) { + if (softmax_param_ != NULL) softmax_param_->::caffe::SoftmaxParameter::Clear(); + } + } + if (_has_bits_[56 / 32] & 1056964608u) { + if (has_spp_param()) { + if (spp_param_ != NULL) spp_param_->::caffe::SPPParameter::Clear(); + } + if (has_slice_param()) { + if (slice_param_ != NULL) slice_param_->::caffe::SliceParameter::Clear(); + } + if (has_tanh_param()) { + if (tanh_param_ != NULL) tanh_param_->::caffe::TanHParameter::Clear(); + } + if (has_threshold_param()) { + if (threshold_param_ != NULL) threshold_param_->::caffe::ThresholdParameter::Clear(); + } + if (has_tile_param()) { + if (tile_param_ != NULL) tile_param_->::caffe::TileParameter::Clear(); + } + if (has_window_data_param()) { + if (window_data_param_ != NULL) window_data_param_->::caffe::WindowDataParameter::Clear(); + } + } + bottom_.Clear(); + top_.Clear(); + loss_weight_.Clear(); + param_.Clear(); + blobs_.Clear(); + propagate_down_.Clear(); + include_.Clear(); + exclude_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool LayerParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.LayerParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.LayerParameter.name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_type; + break; + } + + // optional string type = 2; + case 2: { + if (tag == 18) { + parse_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.LayerParameter.type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_bottom; + break; + } + + // repeated string bottom = 3; + case 3: { + if (tag == 26) { + parse_bottom: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_bottom())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->bottom(this->bottom_size() - 1).data(), + this->bottom(this->bottom_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.LayerParameter.bottom"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_bottom; + if (input->ExpectTag(34)) goto parse_top; + break; + } + + // repeated string top = 4; + case 4: { + if (tag == 34) { + parse_top: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_top())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->top(this->top_size() - 1).data(), + this->top(this->top_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.LayerParameter.top"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_top; + if (input->ExpectTag(45)) goto parse_loss_weight; + break; + } + + // repeated float loss_weight = 5; + case 5: { + if (tag == 45) { + parse_loss_weight: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 45, input, this->mutable_loss_weight()))); + } else if (tag == 42) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_loss_weight()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_loss_weight; + if (input->ExpectTag(50)) goto parse_param; + break; + } + + // repeated .caffe.ParamSpec param = 6; + case 6: { + if (tag == 50) { + parse_param: + DO_(input->IncrementRecursionDepth()); + parse_loop_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_loop_param; + if (input->ExpectTag(58)) goto parse_loop_blobs; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .caffe.BlobProto blobs = 7; + case 7: { + if (tag == 58) { + DO_(input->IncrementRecursionDepth()); + parse_loop_blobs: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_blobs())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_loop_blobs; + if (input->ExpectTag(66)) goto parse_loop_include; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .caffe.NetStateRule include = 8; + case 8: { + if (tag == 66) { + DO_(input->IncrementRecursionDepth()); + parse_loop_include: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_include())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_loop_include; + if (input->ExpectTag(74)) goto parse_loop_exclude; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .caffe.NetStateRule exclude = 9; + case 9: { + if (tag == 74) { + DO_(input->IncrementRecursionDepth()); + parse_loop_exclude: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_exclude())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(74)) goto parse_loop_exclude; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(80)) goto parse_phase; + break; + } + + // optional .caffe.Phase phase = 10; + case 10: { + if (tag == 80) { + parse_phase: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::Phase_IsValid(value)) { + set_phase(static_cast< ::caffe::Phase >(value)); + } else { + mutable_unknown_fields()->AddVarint(10, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_propagate_down; + break; + } + + // repeated bool propagate_down = 11; + case 11: { + if (tag == 88) { + parse_propagate_down: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + 1, 88, input, this->mutable_propagate_down()))); + } else if (tag == 90) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, this->mutable_propagate_down()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_propagate_down; + if (input->ExpectTag(802)) goto parse_transform_param; + break; + } + + // optional .caffe.TransformationParameter transform_param = 100; + case 100: { + if (tag == 802) { + parse_transform_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_transform_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(810)) goto parse_loss_param; + break; + } + + // optional .caffe.LossParameter loss_param = 101; + case 101: { + if (tag == 810) { + parse_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(818)) goto parse_accuracy_param; + break; + } + + // optional .caffe.AccuracyParameter accuracy_param = 102; + case 102: { + if (tag == 818) { + parse_accuracy_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_accuracy_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(826)) goto parse_argmax_param; + break; + } + + // optional .caffe.ArgMaxParameter argmax_param = 103; + case 103: { + if (tag == 826) { + parse_argmax_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_argmax_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(834)) goto parse_concat_param; + break; + } + + // optional .caffe.ConcatParameter concat_param = 104; + case 104: { + if (tag == 834) { + parse_concat_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_concat_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(842)) goto parse_contrastive_loss_param; + break; + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105; + case 105: { + if (tag == 842) { + parse_contrastive_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_contrastive_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(850)) goto parse_convolution_param; + break; + } + + // optional .caffe.ConvolutionParameter convolution_param = 106; + case 106: { + if (tag == 850) { + parse_convolution_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_convolution_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(858)) goto parse_data_param; + break; + } + + // optional .caffe.DataParameter data_param = 107; + case 107: { + if (tag == 858) { + parse_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(866)) goto parse_dropout_param; + break; + } + + // optional .caffe.DropoutParameter dropout_param = 108; + case 108: { + if (tag == 866) { + parse_dropout_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_dropout_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(874)) goto parse_dummy_data_param; + break; + } + + // optional .caffe.DummyDataParameter dummy_data_param = 109; + case 109: { + if (tag == 874) { + parse_dummy_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_dummy_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(882)) goto parse_eltwise_param; + break; + } + + // optional .caffe.EltwiseParameter eltwise_param = 110; + case 110: { + if (tag == 882) { + parse_eltwise_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_eltwise_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(890)) goto parse_exp_param; + break; + } + + // optional .caffe.ExpParameter exp_param = 111; + case 111: { + if (tag == 890) { + parse_exp_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_exp_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(898)) goto parse_hdf5_data_param; + break; + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 112; + case 112: { + if (tag == 898) { + parse_hdf5_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_hdf5_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(906)) goto parse_hdf5_output_param; + break; + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 113; + case 113: { + if (tag == 906) { + parse_hdf5_output_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_hdf5_output_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(914)) goto parse_hinge_loss_param; + break; + } + + // optional .caffe.HingeLossParameter hinge_loss_param = 114; + case 114: { + if (tag == 914) { + parse_hinge_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_hinge_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(922)) goto parse_image_data_param; + break; + } + + // optional .caffe.ImageDataParameter image_data_param = 115; + case 115: { + if (tag == 922) { + parse_image_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_image_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(930)) goto parse_infogain_loss_param; + break; + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 116; + case 116: { + if (tag == 930) { + parse_infogain_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_infogain_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(938)) goto parse_inner_product_param; + break; + } + + // optional .caffe.InnerProductParameter inner_product_param = 117; + case 117: { + if (tag == 938) { + parse_inner_product_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_inner_product_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(946)) goto parse_lrn_param; + break; + } + + // optional .caffe.LRNParameter lrn_param = 118; + case 118: { + if (tag == 946) { + parse_lrn_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_lrn_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(954)) goto parse_memory_data_param; + break; + } + + // optional .caffe.MemoryDataParameter memory_data_param = 119; + case 119: { + if (tag == 954) { + parse_memory_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_memory_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(962)) goto parse_mvn_param; + break; + } + + // optional .caffe.MVNParameter mvn_param = 120; + case 120: { + if (tag == 962) { + parse_mvn_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_mvn_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(970)) goto parse_pooling_param; + break; + } + + // optional .caffe.PoolingParameter pooling_param = 121; + case 121: { + if (tag == 970) { + parse_pooling_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_pooling_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(978)) goto parse_power_param; + break; + } + + // optional .caffe.PowerParameter power_param = 122; + case 122: { + if (tag == 978) { + parse_power_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_power_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(986)) goto parse_relu_param; + break; + } + + // optional .caffe.ReLUParameter relu_param = 123; + case 123: { + if (tag == 986) { + parse_relu_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_relu_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(994)) goto parse_sigmoid_param; + break; + } + + // optional .caffe.SigmoidParameter sigmoid_param = 124; + case 124: { + if (tag == 994) { + parse_sigmoid_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_sigmoid_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1002)) goto parse_softmax_param; + break; + } + + // optional .caffe.SoftmaxParameter softmax_param = 125; + case 125: { + if (tag == 1002) { + parse_softmax_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_softmax_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1010)) goto parse_slice_param; + break; + } + + // optional .caffe.SliceParameter slice_param = 126; + case 126: { + if (tag == 1010) { + parse_slice_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_slice_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1018)) goto parse_tanh_param; + break; + } + + // optional .caffe.TanHParameter tanh_param = 127; + case 127: { + if (tag == 1018) { + parse_tanh_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tanh_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1026)) goto parse_threshold_param; + break; + } + + // optional .caffe.ThresholdParameter threshold_param = 128; + case 128: { + if (tag == 1026) { + parse_threshold_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_threshold_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1034)) goto parse_window_data_param; + break; + } + + // optional .caffe.WindowDataParameter window_data_param = 129; + case 129: { + if (tag == 1034) { + parse_window_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_window_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1042)) goto parse_python_param; + break; + } + + // optional .caffe.PythonParameter python_param = 130; + case 130: { + if (tag == 1042) { + parse_python_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_python_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1050)) goto parse_prelu_param; + break; + } + + // optional .caffe.PReLUParameter prelu_param = 131; + case 131: { + if (tag == 1050) { + parse_prelu_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_prelu_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1058)) goto parse_spp_param; + break; + } + + // optional .caffe.SPPParameter spp_param = 132; + case 132: { + if (tag == 1058) { + parse_spp_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_spp_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1066)) goto parse_reshape_param; + break; + } + + // optional .caffe.ReshapeParameter reshape_param = 133; + case 133: { + if (tag == 1066) { + parse_reshape_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_reshape_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1074)) goto parse_log_param; + break; + } + + // optional .caffe.LogParameter log_param = 134; + case 134: { + if (tag == 1074) { + parse_log_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_log_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1082)) goto parse_flatten_param; + break; + } + + // optional .caffe.FlattenParameter flatten_param = 135; + case 135: { + if (tag == 1082) { + parse_flatten_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_flatten_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1090)) goto parse_reduction_param; + break; + } + + // optional .caffe.ReductionParameter reduction_param = 136; + case 136: { + if (tag == 1090) { + parse_reduction_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_reduction_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1098)) goto parse_embed_param; + break; + } + + // optional .caffe.EmbedParameter embed_param = 137; + case 137: { + if (tag == 1098) { + parse_embed_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_embed_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1106)) goto parse_tile_param; + break; + } + + // optional .caffe.TileParameter tile_param = 138; + case 138: { + if (tag == 1106) { + parse_tile_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tile_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1114)) goto parse_batch_norm_param; + break; + } + + // optional .caffe.BatchNormParameter batch_norm_param = 139; + case 139: { + if (tag == 1114) { + parse_batch_norm_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_batch_norm_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1122)) goto parse_elu_param; + break; + } + + // optional .caffe.ELUParameter elu_param = 140; + case 140: { + if (tag == 1122) { + parse_elu_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_elu_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1130)) goto parse_bias_param; + break; + } + + // optional .caffe.BiasParameter bias_param = 141; + case 141: { + if (tag == 1130) { + parse_bias_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bias_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1138)) goto parse_scale_param; + break; + } + + // optional .caffe.ScaleParameter scale_param = 142; + case 142: { + if (tag == 1138) { + parse_scale_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_scale_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1146)) goto parse_input_param; + break; + } + + // optional .caffe.InputParameter input_param = 143; + case 143: { + if (tag == 1146) { + parse_input_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_input_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1154)) goto parse_crop_param; + break; + } + + // optional .caffe.CropParameter crop_param = 144; + case 144: { + if (tag == 1154) { + parse_crop_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_crop_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1162)) goto parse_parameter_param; + break; + } + + // optional .caffe.ParameterParameter parameter_param = 145; + case 145: { + if (tag == 1162) { + parse_parameter_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_parameter_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1170)) goto parse_recurrent_param; + break; + } + + // optional .caffe.RecurrentParameter recurrent_param = 146; + case 146: { + if (tag == 1170) { + parse_recurrent_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_recurrent_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1178)) goto parse_detection_output_param; + break; + } + + // optional .caffe.DetectionOutputParameter detection_output_param = 147; + case 147: { + if (tag == 1178) { + parse_detection_output_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_detection_output_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1186)) goto parse_permute_param; + break; + } + + // optional .caffe.PermuteParameter permute_param = 148; + case 148: { + if (tag == 1186) { + parse_permute_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_permute_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1194)) goto parse_norm_param; + break; + } + + // optional .caffe.NormalizeBBoxParameter norm_param = 149; + case 149: { + if (tag == 1194) { + parse_norm_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_norm_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(1202)) goto parse_prior_box_param; + break; + } + + // optional .caffe.PriorBoxParameter prior_box_param = 150; + case 150: { + if (tag == 1202) { + parse_prior_box_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_prior_box_param())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.LayerParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.LayerParameter) + return false; +#undef DO_ +} + +void LayerParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.LayerParameter) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional string type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->type(), output); + } + + // repeated string bottom = 3; + for (int i = 0; i < this->bottom_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->bottom(i).data(), this->bottom(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.bottom"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->bottom(i), output); + } + + // repeated string top = 4; + for (int i = 0; i < this->top_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->top(i).data(), this->top(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.top"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->top(i), output); + } + + // repeated float loss_weight = 5; + for (int i = 0; i < this->loss_weight_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 5, this->loss_weight(i), output); + } + + // repeated .caffe.ParamSpec param = 6; + for (unsigned int i = 0, n = this->param_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->param(i), output); + } + + // repeated .caffe.BlobProto blobs = 7; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->blobs(i), output); + } + + // repeated .caffe.NetStateRule include = 8; + for (unsigned int i = 0, n = this->include_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->include(i), output); + } + + // repeated .caffe.NetStateRule exclude = 9; + for (unsigned int i = 0, n = this->exclude_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 9, this->exclude(i), output); + } + + // optional .caffe.Phase phase = 10; + if (has_phase()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 10, this->phase(), output); + } + + // repeated bool propagate_down = 11; + for (int i = 0; i < this->propagate_down_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteBool( + 11, this->propagate_down(i), output); + } + + // optional .caffe.TransformationParameter transform_param = 100; + if (has_transform_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 100, *this->transform_param_, output); + } + + // optional .caffe.LossParameter loss_param = 101; + if (has_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 101, *this->loss_param_, output); + } + + // optional .caffe.AccuracyParameter accuracy_param = 102; + if (has_accuracy_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 102, *this->accuracy_param_, output); + } + + // optional .caffe.ArgMaxParameter argmax_param = 103; + if (has_argmax_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 103, *this->argmax_param_, output); + } + + // optional .caffe.ConcatParameter concat_param = 104; + if (has_concat_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 104, *this->concat_param_, output); + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105; + if (has_contrastive_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 105, *this->contrastive_loss_param_, output); + } + + // optional .caffe.ConvolutionParameter convolution_param = 106; + if (has_convolution_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 106, *this->convolution_param_, output); + } + + // optional .caffe.DataParameter data_param = 107; + if (has_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 107, *this->data_param_, output); + } + + // optional .caffe.DropoutParameter dropout_param = 108; + if (has_dropout_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 108, *this->dropout_param_, output); + } + + // optional .caffe.DummyDataParameter dummy_data_param = 109; + if (has_dummy_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 109, *this->dummy_data_param_, output); + } + + // optional .caffe.EltwiseParameter eltwise_param = 110; + if (has_eltwise_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 110, *this->eltwise_param_, output); + } + + // optional .caffe.ExpParameter exp_param = 111; + if (has_exp_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 111, *this->exp_param_, output); + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 112; + if (has_hdf5_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 112, *this->hdf5_data_param_, output); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 113; + if (has_hdf5_output_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 113, *this->hdf5_output_param_, output); + } + + // optional .caffe.HingeLossParameter hinge_loss_param = 114; + if (has_hinge_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 114, *this->hinge_loss_param_, output); + } + + // optional .caffe.ImageDataParameter image_data_param = 115; + if (has_image_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 115, *this->image_data_param_, output); + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 116; + if (has_infogain_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 116, *this->infogain_loss_param_, output); + } + + // optional .caffe.InnerProductParameter inner_product_param = 117; + if (has_inner_product_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 117, *this->inner_product_param_, output); + } + + // optional .caffe.LRNParameter lrn_param = 118; + if (has_lrn_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 118, *this->lrn_param_, output); + } + + // optional .caffe.MemoryDataParameter memory_data_param = 119; + if (has_memory_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 119, *this->memory_data_param_, output); + } + + // optional .caffe.MVNParameter mvn_param = 120; + if (has_mvn_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 120, *this->mvn_param_, output); + } + + // optional .caffe.PoolingParameter pooling_param = 121; + if (has_pooling_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 121, *this->pooling_param_, output); + } + + // optional .caffe.PowerParameter power_param = 122; + if (has_power_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 122, *this->power_param_, output); + } + + // optional .caffe.ReLUParameter relu_param = 123; + if (has_relu_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 123, *this->relu_param_, output); + } + + // optional .caffe.SigmoidParameter sigmoid_param = 124; + if (has_sigmoid_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 124, *this->sigmoid_param_, output); + } + + // optional .caffe.SoftmaxParameter softmax_param = 125; + if (has_softmax_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 125, *this->softmax_param_, output); + } + + // optional .caffe.SliceParameter slice_param = 126; + if (has_slice_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 126, *this->slice_param_, output); + } + + // optional .caffe.TanHParameter tanh_param = 127; + if (has_tanh_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 127, *this->tanh_param_, output); + } + + // optional .caffe.ThresholdParameter threshold_param = 128; + if (has_threshold_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 128, *this->threshold_param_, output); + } + + // optional .caffe.WindowDataParameter window_data_param = 129; + if (has_window_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 129, *this->window_data_param_, output); + } + + // optional .caffe.PythonParameter python_param = 130; + if (has_python_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 130, *this->python_param_, output); + } + + // optional .caffe.PReLUParameter prelu_param = 131; + if (has_prelu_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 131, *this->prelu_param_, output); + } + + // optional .caffe.SPPParameter spp_param = 132; + if (has_spp_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 132, *this->spp_param_, output); + } + + // optional .caffe.ReshapeParameter reshape_param = 133; + if (has_reshape_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 133, *this->reshape_param_, output); + } + + // optional .caffe.LogParameter log_param = 134; + if (has_log_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 134, *this->log_param_, output); + } + + // optional .caffe.FlattenParameter flatten_param = 135; + if (has_flatten_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 135, *this->flatten_param_, output); + } + + // optional .caffe.ReductionParameter reduction_param = 136; + if (has_reduction_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 136, *this->reduction_param_, output); + } + + // optional .caffe.EmbedParameter embed_param = 137; + if (has_embed_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 137, *this->embed_param_, output); + } + + // optional .caffe.TileParameter tile_param = 138; + if (has_tile_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 138, *this->tile_param_, output); + } + + // optional .caffe.BatchNormParameter batch_norm_param = 139; + if (has_batch_norm_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 139, *this->batch_norm_param_, output); + } + + // optional .caffe.ELUParameter elu_param = 140; + if (has_elu_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 140, *this->elu_param_, output); + } + + // optional .caffe.BiasParameter bias_param = 141; + if (has_bias_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 141, *this->bias_param_, output); + } + + // optional .caffe.ScaleParameter scale_param = 142; + if (has_scale_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 142, *this->scale_param_, output); + } + + // optional .caffe.InputParameter input_param = 143; + if (has_input_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 143, *this->input_param_, output); + } + + // optional .caffe.CropParameter crop_param = 144; + if (has_crop_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 144, *this->crop_param_, output); + } + + // optional .caffe.ParameterParameter parameter_param = 145; + if (has_parameter_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 145, *this->parameter_param_, output); + } + + // optional .caffe.RecurrentParameter recurrent_param = 146; + if (has_recurrent_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 146, *this->recurrent_param_, output); + } + + // optional .caffe.DetectionOutputParameter detection_output_param = 147; + if (has_detection_output_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 147, *this->detection_output_param_, output); + } + + // optional .caffe.PermuteParameter permute_param = 148; + if (has_permute_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 148, *this->permute_param_, output); + } + + // optional .caffe.NormalizeBBoxParameter norm_param = 149; + if (has_norm_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 149, *this->norm_param_, output); + } + + // optional .caffe.PriorBoxParameter prior_box_param = 150; + if (has_prior_box_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 150, *this->prior_box_param_, output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.LayerParameter) +} + +::google::protobuf::uint8* LayerParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.LayerParameter) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional string type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->type(), target); + } + + // repeated string bottom = 3; + for (int i = 0; i < this->bottom_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->bottom(i).data(), this->bottom(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.bottom"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->bottom(i), target); + } + + // repeated string top = 4; + for (int i = 0; i < this->top_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->top(i).data(), this->top(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.LayerParameter.top"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(4, this->top(i), target); + } + + // repeated float loss_weight = 5; + for (int i = 0; i < this->loss_weight_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(5, this->loss_weight(i), target); + } + + // repeated .caffe.ParamSpec param = 6; + for (unsigned int i = 0, n = this->param_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 6, this->param(i), false, target); + } + + // repeated .caffe.BlobProto blobs = 7; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 7, this->blobs(i), false, target); + } + + // repeated .caffe.NetStateRule include = 8; + for (unsigned int i = 0, n = this->include_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 8, this->include(i), false, target); + } + + // repeated .caffe.NetStateRule exclude = 9; + for (unsigned int i = 0, n = this->exclude_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 9, this->exclude(i), false, target); + } + + // optional .caffe.Phase phase = 10; + if (has_phase()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 10, this->phase(), target); + } + + // repeated bool propagate_down = 11; + for (int i = 0; i < this->propagate_down_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBoolToArray(11, this->propagate_down(i), target); + } + + // optional .caffe.TransformationParameter transform_param = 100; + if (has_transform_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 100, *this->transform_param_, false, target); + } + + // optional .caffe.LossParameter loss_param = 101; + if (has_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 101, *this->loss_param_, false, target); + } + + // optional .caffe.AccuracyParameter accuracy_param = 102; + if (has_accuracy_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 102, *this->accuracy_param_, false, target); + } + + // optional .caffe.ArgMaxParameter argmax_param = 103; + if (has_argmax_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 103, *this->argmax_param_, false, target); + } + + // optional .caffe.ConcatParameter concat_param = 104; + if (has_concat_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 104, *this->concat_param_, false, target); + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105; + if (has_contrastive_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 105, *this->contrastive_loss_param_, false, target); + } + + // optional .caffe.ConvolutionParameter convolution_param = 106; + if (has_convolution_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 106, *this->convolution_param_, false, target); + } + + // optional .caffe.DataParameter data_param = 107; + if (has_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 107, *this->data_param_, false, target); + } + + // optional .caffe.DropoutParameter dropout_param = 108; + if (has_dropout_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 108, *this->dropout_param_, false, target); + } + + // optional .caffe.DummyDataParameter dummy_data_param = 109; + if (has_dummy_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 109, *this->dummy_data_param_, false, target); + } + + // optional .caffe.EltwiseParameter eltwise_param = 110; + if (has_eltwise_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 110, *this->eltwise_param_, false, target); + } + + // optional .caffe.ExpParameter exp_param = 111; + if (has_exp_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 111, *this->exp_param_, false, target); + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 112; + if (has_hdf5_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 112, *this->hdf5_data_param_, false, target); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 113; + if (has_hdf5_output_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 113, *this->hdf5_output_param_, false, target); + } + + // optional .caffe.HingeLossParameter hinge_loss_param = 114; + if (has_hinge_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 114, *this->hinge_loss_param_, false, target); + } + + // optional .caffe.ImageDataParameter image_data_param = 115; + if (has_image_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 115, *this->image_data_param_, false, target); + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 116; + if (has_infogain_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 116, *this->infogain_loss_param_, false, target); + } + + // optional .caffe.InnerProductParameter inner_product_param = 117; + if (has_inner_product_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 117, *this->inner_product_param_, false, target); + } + + // optional .caffe.LRNParameter lrn_param = 118; + if (has_lrn_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 118, *this->lrn_param_, false, target); + } + + // optional .caffe.MemoryDataParameter memory_data_param = 119; + if (has_memory_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 119, *this->memory_data_param_, false, target); + } + + // optional .caffe.MVNParameter mvn_param = 120; + if (has_mvn_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 120, *this->mvn_param_, false, target); + } + + // optional .caffe.PoolingParameter pooling_param = 121; + if (has_pooling_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 121, *this->pooling_param_, false, target); + } + + // optional .caffe.PowerParameter power_param = 122; + if (has_power_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 122, *this->power_param_, false, target); + } + + // optional .caffe.ReLUParameter relu_param = 123; + if (has_relu_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 123, *this->relu_param_, false, target); + } + + // optional .caffe.SigmoidParameter sigmoid_param = 124; + if (has_sigmoid_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 124, *this->sigmoid_param_, false, target); + } + + // optional .caffe.SoftmaxParameter softmax_param = 125; + if (has_softmax_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 125, *this->softmax_param_, false, target); + } + + // optional .caffe.SliceParameter slice_param = 126; + if (has_slice_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 126, *this->slice_param_, false, target); + } + + // optional .caffe.TanHParameter tanh_param = 127; + if (has_tanh_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 127, *this->tanh_param_, false, target); + } + + // optional .caffe.ThresholdParameter threshold_param = 128; + if (has_threshold_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 128, *this->threshold_param_, false, target); + } + + // optional .caffe.WindowDataParameter window_data_param = 129; + if (has_window_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 129, *this->window_data_param_, false, target); + } + + // optional .caffe.PythonParameter python_param = 130; + if (has_python_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 130, *this->python_param_, false, target); + } + + // optional .caffe.PReLUParameter prelu_param = 131; + if (has_prelu_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 131, *this->prelu_param_, false, target); + } + + // optional .caffe.SPPParameter spp_param = 132; + if (has_spp_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 132, *this->spp_param_, false, target); + } + + // optional .caffe.ReshapeParameter reshape_param = 133; + if (has_reshape_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 133, *this->reshape_param_, false, target); + } + + // optional .caffe.LogParameter log_param = 134; + if (has_log_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 134, *this->log_param_, false, target); + } + + // optional .caffe.FlattenParameter flatten_param = 135; + if (has_flatten_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 135, *this->flatten_param_, false, target); + } + + // optional .caffe.ReductionParameter reduction_param = 136; + if (has_reduction_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 136, *this->reduction_param_, false, target); + } + + // optional .caffe.EmbedParameter embed_param = 137; + if (has_embed_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 137, *this->embed_param_, false, target); + } + + // optional .caffe.TileParameter tile_param = 138; + if (has_tile_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 138, *this->tile_param_, false, target); + } + + // optional .caffe.BatchNormParameter batch_norm_param = 139; + if (has_batch_norm_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 139, *this->batch_norm_param_, false, target); + } + + // optional .caffe.ELUParameter elu_param = 140; + if (has_elu_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 140, *this->elu_param_, false, target); + } + + // optional .caffe.BiasParameter bias_param = 141; + if (has_bias_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 141, *this->bias_param_, false, target); + } + + // optional .caffe.ScaleParameter scale_param = 142; + if (has_scale_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 142, *this->scale_param_, false, target); + } + + // optional .caffe.InputParameter input_param = 143; + if (has_input_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 143, *this->input_param_, false, target); + } + + // optional .caffe.CropParameter crop_param = 144; + if (has_crop_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 144, *this->crop_param_, false, target); + } + + // optional .caffe.ParameterParameter parameter_param = 145; + if (has_parameter_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 145, *this->parameter_param_, false, target); + } + + // optional .caffe.RecurrentParameter recurrent_param = 146; + if (has_recurrent_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 146, *this->recurrent_param_, false, target); + } + + // optional .caffe.DetectionOutputParameter detection_output_param = 147; + if (has_detection_output_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 147, *this->detection_output_param_, false, target); + } + + // optional .caffe.PermuteParameter permute_param = 148; + if (has_permute_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 148, *this->permute_param_, false, target); + } + + // optional .caffe.NormalizeBBoxParameter norm_param = 149; + if (has_norm_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 149, *this->norm_param_, false, target); + } + + // optional .caffe.PriorBoxParameter prior_box_param = 150; + if (has_prior_box_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 150, *this->prior_box_param_, false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.LayerParameter) + return target; +} + +size_t LayerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.LayerParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 19u) { + // optional string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string type = 2; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + // optional .caffe.Phase phase = 10; + if (has_phase()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->phase()); + } + + } + if (_has_bits_[11 / 32] & 63488u) { + // optional .caffe.TransformationParameter transform_param = 100; + if (has_transform_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->transform_param_); + } + + // optional .caffe.LossParameter loss_param = 101; + if (has_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->loss_param_); + } + + // optional .caffe.AccuracyParameter accuracy_param = 102; + if (has_accuracy_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->accuracy_param_); + } + + // optional .caffe.ArgMaxParameter argmax_param = 103; + if (has_argmax_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->argmax_param_); + } + + // optional .caffe.BatchNormParameter batch_norm_param = 139; + if (has_batch_norm_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->batch_norm_param_); + } + + } + if (_has_bits_[16 / 32] & 16711680u) { + // optional .caffe.BiasParameter bias_param = 141; + if (has_bias_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->bias_param_); + } + + // optional .caffe.ConcatParameter concat_param = 104; + if (has_concat_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->concat_param_); + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105; + if (has_contrastive_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->contrastive_loss_param_); + } + + // optional .caffe.ConvolutionParameter convolution_param = 106; + if (has_convolution_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->convolution_param_); + } + + // optional .caffe.CropParameter crop_param = 144; + if (has_crop_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->crop_param_); + } + + // optional .caffe.DataParameter data_param = 107; + if (has_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->data_param_); + } + + // optional .caffe.DetectionOutputParameter detection_output_param = 147; + if (has_detection_output_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->detection_output_param_); + } + + // optional .caffe.DropoutParameter dropout_param = 108; + if (has_dropout_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->dropout_param_); + } + + } + if (_has_bits_[24 / 32] & 4278190080u) { + // optional .caffe.DummyDataParameter dummy_data_param = 109; + if (has_dummy_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->dummy_data_param_); + } + + // optional .caffe.EltwiseParameter eltwise_param = 110; + if (has_eltwise_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->eltwise_param_); + } + + // optional .caffe.ELUParameter elu_param = 140; + if (has_elu_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->elu_param_); + } + + // optional .caffe.EmbedParameter embed_param = 137; + if (has_embed_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->embed_param_); + } + + // optional .caffe.ExpParameter exp_param = 111; + if (has_exp_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->exp_param_); + } + + // optional .caffe.FlattenParameter flatten_param = 135; + if (has_flatten_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->flatten_param_); + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 112; + if (has_hdf5_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->hdf5_data_param_); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 113; + if (has_hdf5_output_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->hdf5_output_param_); + } + + } + if (_has_bits_[32 / 32] & 255u) { + // optional .caffe.HingeLossParameter hinge_loss_param = 114; + if (has_hinge_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->hinge_loss_param_); + } + + // optional .caffe.ImageDataParameter image_data_param = 115; + if (has_image_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->image_data_param_); + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 116; + if (has_infogain_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->infogain_loss_param_); + } + + // optional .caffe.InnerProductParameter inner_product_param = 117; + if (has_inner_product_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->inner_product_param_); + } + + // optional .caffe.InputParameter input_param = 143; + if (has_input_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->input_param_); + } + + // optional .caffe.LogParameter log_param = 134; + if (has_log_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->log_param_); + } + + // optional .caffe.LRNParameter lrn_param = 118; + if (has_lrn_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->lrn_param_); + } + + // optional .caffe.MemoryDataParameter memory_data_param = 119; + if (has_memory_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->memory_data_param_); + } + + } + if (_has_bits_[40 / 32] & 65280u) { + // optional .caffe.MVNParameter mvn_param = 120; + if (has_mvn_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->mvn_param_); + } + + // optional .caffe.NormalizeBBoxParameter norm_param = 149; + if (has_norm_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->norm_param_); + } + + // optional .caffe.PermuteParameter permute_param = 148; + if (has_permute_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->permute_param_); + } + + // optional .caffe.ParameterParameter parameter_param = 145; + if (has_parameter_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->parameter_param_); + } + + // optional .caffe.PoolingParameter pooling_param = 121; + if (has_pooling_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->pooling_param_); + } + + // optional .caffe.PowerParameter power_param = 122; + if (has_power_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->power_param_); + } + + // optional .caffe.PReLUParameter prelu_param = 131; + if (has_prelu_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->prelu_param_); + } + + // optional .caffe.PriorBoxParameter prior_box_param = 150; + if (has_prior_box_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->prior_box_param_); + } + + } + if (_has_bits_[48 / 32] & 16711680u) { + // optional .caffe.PythonParameter python_param = 130; + if (has_python_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->python_param_); + } + + // optional .caffe.RecurrentParameter recurrent_param = 146; + if (has_recurrent_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->recurrent_param_); + } + + // optional .caffe.ReductionParameter reduction_param = 136; + if (has_reduction_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->reduction_param_); + } + + // optional .caffe.ReLUParameter relu_param = 123; + if (has_relu_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->relu_param_); + } + + // optional .caffe.ReshapeParameter reshape_param = 133; + if (has_reshape_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->reshape_param_); + } + + // optional .caffe.ScaleParameter scale_param = 142; + if (has_scale_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->scale_param_); + } + + // optional .caffe.SigmoidParameter sigmoid_param = 124; + if (has_sigmoid_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->sigmoid_param_); + } + + // optional .caffe.SoftmaxParameter softmax_param = 125; + if (has_softmax_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->softmax_param_); + } + + } + if (_has_bits_[56 / 32] & 1056964608u) { + // optional .caffe.SPPParameter spp_param = 132; + if (has_spp_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->spp_param_); + } + + // optional .caffe.SliceParameter slice_param = 126; + if (has_slice_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->slice_param_); + } + + // optional .caffe.TanHParameter tanh_param = 127; + if (has_tanh_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->tanh_param_); + } + + // optional .caffe.ThresholdParameter threshold_param = 128; + if (has_threshold_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->threshold_param_); + } + + // optional .caffe.TileParameter tile_param = 138; + if (has_tile_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->tile_param_); + } + + // optional .caffe.WindowDataParameter window_data_param = 129; + if (has_window_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->window_data_param_); + } + + } + // repeated string bottom = 3; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->bottom_size()); + for (int i = 0; i < this->bottom_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->bottom(i)); + } + + // repeated string top = 4; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->top_size()); + for (int i = 0; i < this->top_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->top(i)); + } + + // repeated float loss_weight = 5; + { + size_t data_size = 0; + unsigned int count = this->loss_weight_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->loss_weight_size()); + total_size += data_size; + } + + // repeated .caffe.ParamSpec param = 6; + { + unsigned int count = this->param_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->param(i)); + } + } + + // repeated .caffe.BlobProto blobs = 7; + { + unsigned int count = this->blobs_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blobs(i)); + } + } + + // repeated bool propagate_down = 11; + { + size_t data_size = 0; + unsigned int count = this->propagate_down_size(); + data_size = 1UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->propagate_down_size()); + total_size += data_size; + } + + // repeated .caffe.NetStateRule include = 8; + { + unsigned int count = this->include_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->include(i)); + } + } + + // repeated .caffe.NetStateRule exclude = 9; + { + unsigned int count = this->exclude_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->exclude(i)); + } + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void LayerParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.LayerParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const LayerParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.LayerParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.LayerParameter) + UnsafeMergeFrom(*source); + } +} + +void LayerParameter::MergeFrom(const LayerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.LayerParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void LayerParameter::UnsafeMergeFrom(const LayerParameter& from) { + GOOGLE_DCHECK(&from != this); + bottom_.UnsafeMergeFrom(from.bottom_); + top_.UnsafeMergeFrom(from.top_); + loss_weight_.UnsafeMergeFrom(from.loss_weight_); + param_.MergeFrom(from.param_); + blobs_.MergeFrom(from.blobs_); + propagate_down_.UnsafeMergeFrom(from.propagate_down_); + include_.MergeFrom(from.include_); + exclude_.MergeFrom(from.exclude_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_type()) { + set_has_type(); + type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_); + } + if (from.has_phase()) { + set_phase(from.phase()); + } + } + if (from._has_bits_[11 / 32] & (0xffu << (11 % 32))) { + if (from.has_transform_param()) { + mutable_transform_param()->::caffe::TransformationParameter::MergeFrom(from.transform_param()); + } + if (from.has_loss_param()) { + mutable_loss_param()->::caffe::LossParameter::MergeFrom(from.loss_param()); + } + if (from.has_accuracy_param()) { + mutable_accuracy_param()->::caffe::AccuracyParameter::MergeFrom(from.accuracy_param()); + } + if (from.has_argmax_param()) { + mutable_argmax_param()->::caffe::ArgMaxParameter::MergeFrom(from.argmax_param()); + } + if (from.has_batch_norm_param()) { + mutable_batch_norm_param()->::caffe::BatchNormParameter::MergeFrom(from.batch_norm_param()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from.has_bias_param()) { + mutable_bias_param()->::caffe::BiasParameter::MergeFrom(from.bias_param()); + } + if (from.has_concat_param()) { + mutable_concat_param()->::caffe::ConcatParameter::MergeFrom(from.concat_param()); + } + if (from.has_contrastive_loss_param()) { + mutable_contrastive_loss_param()->::caffe::ContrastiveLossParameter::MergeFrom(from.contrastive_loss_param()); + } + if (from.has_convolution_param()) { + mutable_convolution_param()->::caffe::ConvolutionParameter::MergeFrom(from.convolution_param()); + } + if (from.has_crop_param()) { + mutable_crop_param()->::caffe::CropParameter::MergeFrom(from.crop_param()); + } + if (from.has_data_param()) { + mutable_data_param()->::caffe::DataParameter::MergeFrom(from.data_param()); + } + if (from.has_detection_output_param()) { + mutable_detection_output_param()->::caffe::DetectionOutputParameter::MergeFrom(from.detection_output_param()); + } + if (from.has_dropout_param()) { + mutable_dropout_param()->::caffe::DropoutParameter::MergeFrom(from.dropout_param()); + } + } + if (from._has_bits_[24 / 32] & (0xffu << (24 % 32))) { + if (from.has_dummy_data_param()) { + mutable_dummy_data_param()->::caffe::DummyDataParameter::MergeFrom(from.dummy_data_param()); + } + if (from.has_eltwise_param()) { + mutable_eltwise_param()->::caffe::EltwiseParameter::MergeFrom(from.eltwise_param()); + } + if (from.has_elu_param()) { + mutable_elu_param()->::caffe::ELUParameter::MergeFrom(from.elu_param()); + } + if (from.has_embed_param()) { + mutable_embed_param()->::caffe::EmbedParameter::MergeFrom(from.embed_param()); + } + if (from.has_exp_param()) { + mutable_exp_param()->::caffe::ExpParameter::MergeFrom(from.exp_param()); + } + if (from.has_flatten_param()) { + mutable_flatten_param()->::caffe::FlattenParameter::MergeFrom(from.flatten_param()); + } + if (from.has_hdf5_data_param()) { + mutable_hdf5_data_param()->::caffe::HDF5DataParameter::MergeFrom(from.hdf5_data_param()); + } + if (from.has_hdf5_output_param()) { + mutable_hdf5_output_param()->::caffe::HDF5OutputParameter::MergeFrom(from.hdf5_output_param()); + } + } + if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) { + if (from.has_hinge_loss_param()) { + mutable_hinge_loss_param()->::caffe::HingeLossParameter::MergeFrom(from.hinge_loss_param()); + } + if (from.has_image_data_param()) { + mutable_image_data_param()->::caffe::ImageDataParameter::MergeFrom(from.image_data_param()); + } + if (from.has_infogain_loss_param()) { + mutable_infogain_loss_param()->::caffe::InfogainLossParameter::MergeFrom(from.infogain_loss_param()); + } + if (from.has_inner_product_param()) { + mutable_inner_product_param()->::caffe::InnerProductParameter::MergeFrom(from.inner_product_param()); + } + if (from.has_input_param()) { + mutable_input_param()->::caffe::InputParameter::MergeFrom(from.input_param()); + } + if (from.has_log_param()) { + mutable_log_param()->::caffe::LogParameter::MergeFrom(from.log_param()); + } + if (from.has_lrn_param()) { + mutable_lrn_param()->::caffe::LRNParameter::MergeFrom(from.lrn_param()); + } + if (from.has_memory_data_param()) { + mutable_memory_data_param()->::caffe::MemoryDataParameter::MergeFrom(from.memory_data_param()); + } + } + if (from._has_bits_[40 / 32] & (0xffu << (40 % 32))) { + if (from.has_mvn_param()) { + mutable_mvn_param()->::caffe::MVNParameter::MergeFrom(from.mvn_param()); + } + if (from.has_norm_param()) { + mutable_norm_param()->::caffe::NormalizeBBoxParameter::MergeFrom(from.norm_param()); + } + if (from.has_permute_param()) { + mutable_permute_param()->::caffe::PermuteParameter::MergeFrom(from.permute_param()); + } + if (from.has_parameter_param()) { + mutable_parameter_param()->::caffe::ParameterParameter::MergeFrom(from.parameter_param()); + } + if (from.has_pooling_param()) { + mutable_pooling_param()->::caffe::PoolingParameter::MergeFrom(from.pooling_param()); + } + if (from.has_power_param()) { + mutable_power_param()->::caffe::PowerParameter::MergeFrom(from.power_param()); + } + if (from.has_prelu_param()) { + mutable_prelu_param()->::caffe::PReLUParameter::MergeFrom(from.prelu_param()); + } + if (from.has_prior_box_param()) { + mutable_prior_box_param()->::caffe::PriorBoxParameter::MergeFrom(from.prior_box_param()); + } + } + if (from._has_bits_[48 / 32] & (0xffu << (48 % 32))) { + if (from.has_python_param()) { + mutable_python_param()->::caffe::PythonParameter::MergeFrom(from.python_param()); + } + if (from.has_recurrent_param()) { + mutable_recurrent_param()->::caffe::RecurrentParameter::MergeFrom(from.recurrent_param()); + } + if (from.has_reduction_param()) { + mutable_reduction_param()->::caffe::ReductionParameter::MergeFrom(from.reduction_param()); + } + if (from.has_relu_param()) { + mutable_relu_param()->::caffe::ReLUParameter::MergeFrom(from.relu_param()); + } + if (from.has_reshape_param()) { + mutable_reshape_param()->::caffe::ReshapeParameter::MergeFrom(from.reshape_param()); + } + if (from.has_scale_param()) { + mutable_scale_param()->::caffe::ScaleParameter::MergeFrom(from.scale_param()); + } + if (from.has_sigmoid_param()) { + mutable_sigmoid_param()->::caffe::SigmoidParameter::MergeFrom(from.sigmoid_param()); + } + if (from.has_softmax_param()) { + mutable_softmax_param()->::caffe::SoftmaxParameter::MergeFrom(from.softmax_param()); + } + } + if (from._has_bits_[56 / 32] & (0xffu << (56 % 32))) { + if (from.has_spp_param()) { + mutable_spp_param()->::caffe::SPPParameter::MergeFrom(from.spp_param()); + } + if (from.has_slice_param()) { + mutable_slice_param()->::caffe::SliceParameter::MergeFrom(from.slice_param()); + } + if (from.has_tanh_param()) { + mutable_tanh_param()->::caffe::TanHParameter::MergeFrom(from.tanh_param()); + } + if (from.has_threshold_param()) { + mutable_threshold_param()->::caffe::ThresholdParameter::MergeFrom(from.threshold_param()); + } + if (from.has_tile_param()) { + mutable_tile_param()->::caffe::TileParameter::MergeFrom(from.tile_param()); + } + if (from.has_window_data_param()) { + mutable_window_data_param()->::caffe::WindowDataParameter::MergeFrom(from.window_data_param()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void LayerParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.LayerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LayerParameter::CopyFrom(const LayerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.LayerParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool LayerParameter::IsInitialized() const { + + return true; +} + +void LayerParameter::Swap(LayerParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void LayerParameter::InternalSwap(LayerParameter* other) { + name_.Swap(&other->name_); + type_.Swap(&other->type_); + bottom_.UnsafeArenaSwap(&other->bottom_); + top_.UnsafeArenaSwap(&other->top_); + std::swap(phase_, other->phase_); + loss_weight_.UnsafeArenaSwap(&other->loss_weight_); + param_.UnsafeArenaSwap(&other->param_); + blobs_.UnsafeArenaSwap(&other->blobs_); + propagate_down_.UnsafeArenaSwap(&other->propagate_down_); + include_.UnsafeArenaSwap(&other->include_); + exclude_.UnsafeArenaSwap(&other->exclude_); + std::swap(transform_param_, other->transform_param_); + std::swap(loss_param_, other->loss_param_); + std::swap(accuracy_param_, other->accuracy_param_); + std::swap(argmax_param_, other->argmax_param_); + std::swap(batch_norm_param_, other->batch_norm_param_); + std::swap(bias_param_, other->bias_param_); + std::swap(concat_param_, other->concat_param_); + std::swap(contrastive_loss_param_, other->contrastive_loss_param_); + std::swap(convolution_param_, other->convolution_param_); + std::swap(crop_param_, other->crop_param_); + std::swap(data_param_, other->data_param_); + std::swap(detection_output_param_, other->detection_output_param_); + std::swap(dropout_param_, other->dropout_param_); + std::swap(dummy_data_param_, other->dummy_data_param_); + std::swap(eltwise_param_, other->eltwise_param_); + std::swap(elu_param_, other->elu_param_); + std::swap(embed_param_, other->embed_param_); + std::swap(exp_param_, other->exp_param_); + std::swap(flatten_param_, other->flatten_param_); + std::swap(hdf5_data_param_, other->hdf5_data_param_); + std::swap(hdf5_output_param_, other->hdf5_output_param_); + std::swap(hinge_loss_param_, other->hinge_loss_param_); + std::swap(image_data_param_, other->image_data_param_); + std::swap(infogain_loss_param_, other->infogain_loss_param_); + std::swap(inner_product_param_, other->inner_product_param_); + std::swap(input_param_, other->input_param_); + std::swap(log_param_, other->log_param_); + std::swap(lrn_param_, other->lrn_param_); + std::swap(memory_data_param_, other->memory_data_param_); + std::swap(mvn_param_, other->mvn_param_); + std::swap(norm_param_, other->norm_param_); + std::swap(permute_param_, other->permute_param_); + std::swap(parameter_param_, other->parameter_param_); + std::swap(pooling_param_, other->pooling_param_); + std::swap(power_param_, other->power_param_); + std::swap(prelu_param_, other->prelu_param_); + std::swap(prior_box_param_, other->prior_box_param_); + std::swap(python_param_, other->python_param_); + std::swap(recurrent_param_, other->recurrent_param_); + std::swap(reduction_param_, other->reduction_param_); + std::swap(relu_param_, other->relu_param_); + std::swap(reshape_param_, other->reshape_param_); + std::swap(scale_param_, other->scale_param_); + std::swap(sigmoid_param_, other->sigmoid_param_); + std::swap(softmax_param_, other->softmax_param_); + std::swap(spp_param_, other->spp_param_); + std::swap(slice_param_, other->slice_param_); + std::swap(tanh_param_, other->tanh_param_); + std::swap(threshold_param_, other->threshold_param_); + std::swap(tile_param_, other->tile_param_); + std::swap(window_data_param_, other->window_data_param_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_has_bits_[1], other->_has_bits_[1]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata LayerParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LayerParameter_descriptor_; + metadata.reflection = LayerParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// LayerParameter + +// optional string name = 1; +bool LayerParameter::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void LayerParameter::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +void LayerParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +void LayerParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +const ::std::string& LayerParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void LayerParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.name) +} +void LayerParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.name) +} +void LayerParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.name) +} +::std::string* LayerParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void LayerParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.name) +} + +// optional string type = 2; +bool LayerParameter::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void LayerParameter::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +void LayerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +void LayerParameter::clear_type() { + type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_type(); +} +const ::std::string& LayerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.type) + return type_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void LayerParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.type) +} +void LayerParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.type) +} +void LayerParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.type) +} +::std::string* LayerParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.type) + return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* LayerParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void LayerParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type); + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.type) +} + +// repeated string bottom = 3; +int LayerParameter::bottom_size() const { + return bottom_.size(); +} +void LayerParameter::clear_bottom() { + bottom_.Clear(); +} +const ::std::string& LayerParameter::bottom(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.bottom) + return bottom_.Get(index); +} +::std::string* LayerParameter::mutable_bottom(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.bottom) + return bottom_.Mutable(index); +} +void LayerParameter::set_bottom(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.LayerParameter.bottom) + bottom_.Mutable(index)->assign(value); +} +void LayerParameter::set_bottom(int index, const char* value) { + bottom_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.bottom) +} +void LayerParameter::set_bottom(int index, const char* value, size_t size) { + bottom_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.bottom) +} +::std::string* LayerParameter::add_bottom() { + // @@protoc_insertion_point(field_add_mutable:caffe.LayerParameter.bottom) + return bottom_.Add(); +} +void LayerParameter::add_bottom(const ::std::string& value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.bottom) +} +void LayerParameter::add_bottom(const char* value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.LayerParameter.bottom) +} +void LayerParameter::add_bottom(const char* value, size_t size) { + bottom_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.bottom) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +LayerParameter::bottom() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.bottom) + return bottom_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +LayerParameter::mutable_bottom() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.bottom) + return &bottom_; +} + +// repeated string top = 4; +int LayerParameter::top_size() const { + return top_.size(); +} +void LayerParameter::clear_top() { + top_.Clear(); +} +const ::std::string& LayerParameter::top(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.top) + return top_.Get(index); +} +::std::string* LayerParameter::mutable_top(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.top) + return top_.Mutable(index); +} +void LayerParameter::set_top(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.LayerParameter.top) + top_.Mutable(index)->assign(value); +} +void LayerParameter::set_top(int index, const char* value) { + top_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.top) +} +void LayerParameter::set_top(int index, const char* value, size_t size) { + top_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.top) +} +::std::string* LayerParameter::add_top() { + // @@protoc_insertion_point(field_add_mutable:caffe.LayerParameter.top) + return top_.Add(); +} +void LayerParameter::add_top(const ::std::string& value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.top) +} +void LayerParameter::add_top(const char* value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.LayerParameter.top) +} +void LayerParameter::add_top(const char* value, size_t size) { + top_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.top) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +LayerParameter::top() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.top) + return top_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +LayerParameter::mutable_top() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.top) + return &top_; +} + +// optional .caffe.Phase phase = 10; +bool LayerParameter::has_phase() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void LayerParameter::set_has_phase() { + _has_bits_[0] |= 0x00000010u; +} +void LayerParameter::clear_has_phase() { + _has_bits_[0] &= ~0x00000010u; +} +void LayerParameter::clear_phase() { + phase_ = 0; + clear_has_phase(); +} +::caffe::Phase LayerParameter::phase() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.phase) + return static_cast< ::caffe::Phase >(phase_); +} +void LayerParameter::set_phase(::caffe::Phase value) { + assert(::caffe::Phase_IsValid(value)); + set_has_phase(); + phase_ = value; + // @@protoc_insertion_point(field_set:caffe.LayerParameter.phase) +} + +// repeated float loss_weight = 5; +int LayerParameter::loss_weight_size() const { + return loss_weight_.size(); +} +void LayerParameter::clear_loss_weight() { + loss_weight_.Clear(); +} +float LayerParameter::loss_weight(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.loss_weight) + return loss_weight_.Get(index); +} +void LayerParameter::set_loss_weight(int index, float value) { + loss_weight_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.loss_weight) +} +void LayerParameter::add_loss_weight(float value) { + loss_weight_.Add(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.loss_weight) +} +const ::google::protobuf::RepeatedField< float >& +LayerParameter::loss_weight() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.loss_weight) + return loss_weight_; +} +::google::protobuf::RepeatedField< float >* +LayerParameter::mutable_loss_weight() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.loss_weight) + return &loss_weight_; +} + +// repeated .caffe.ParamSpec param = 6; +int LayerParameter::param_size() const { + return param_.size(); +} +void LayerParameter::clear_param() { + param_.Clear(); +} +const ::caffe::ParamSpec& LayerParameter::param(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.param) + return param_.Get(index); +} +::caffe::ParamSpec* LayerParameter::mutable_param(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.param) + return param_.Mutable(index); +} +::caffe::ParamSpec* LayerParameter::add_param() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.param) + return param_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::ParamSpec >* +LayerParameter::mutable_param() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.param) + return ¶m_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::ParamSpec >& +LayerParameter::param() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.param) + return param_; +} + +// repeated .caffe.BlobProto blobs = 7; +int LayerParameter::blobs_size() const { + return blobs_.size(); +} +void LayerParameter::clear_blobs() { + blobs_.Clear(); +} +const ::caffe::BlobProto& LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.blobs) + return blobs_.Get(index); +} +::caffe::BlobProto* LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.blobs) + return blobs_.Mutable(index); +} +::caffe::BlobProto* LayerParameter::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.blobs) + return blobs_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.blobs) + return &blobs_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +LayerParameter::blobs() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.blobs) + return blobs_; +} + +// repeated bool propagate_down = 11; +int LayerParameter::propagate_down_size() const { + return propagate_down_.size(); +} +void LayerParameter::clear_propagate_down() { + propagate_down_.Clear(); +} +bool LayerParameter::propagate_down(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.propagate_down) + return propagate_down_.Get(index); +} +void LayerParameter::set_propagate_down(int index, bool value) { + propagate_down_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.propagate_down) +} +void LayerParameter::add_propagate_down(bool value) { + propagate_down_.Add(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.propagate_down) +} +const ::google::protobuf::RepeatedField< bool >& +LayerParameter::propagate_down() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.propagate_down) + return propagate_down_; +} +::google::protobuf::RepeatedField< bool >* +LayerParameter::mutable_propagate_down() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.propagate_down) + return &propagate_down_; +} + +// repeated .caffe.NetStateRule include = 8; +int LayerParameter::include_size() const { + return include_.size(); +} +void LayerParameter::clear_include() { + include_.Clear(); +} +const ::caffe::NetStateRule& LayerParameter::include(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.include) + return include_.Get(index); +} +::caffe::NetStateRule* LayerParameter::mutable_include(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.include) + return include_.Mutable(index); +} +::caffe::NetStateRule* LayerParameter::add_include() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.include) + return include_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +LayerParameter::mutable_include() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.include) + return &include_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +LayerParameter::include() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.include) + return include_; +} + +// repeated .caffe.NetStateRule exclude = 9; +int LayerParameter::exclude_size() const { + return exclude_.size(); +} +void LayerParameter::clear_exclude() { + exclude_.Clear(); +} +const ::caffe::NetStateRule& LayerParameter::exclude(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.exclude) + return exclude_.Get(index); +} +::caffe::NetStateRule* LayerParameter::mutable_exclude(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.exclude) + return exclude_.Mutable(index); +} +::caffe::NetStateRule* LayerParameter::add_exclude() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.exclude) + return exclude_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +LayerParameter::mutable_exclude() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.exclude) + return &exclude_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +LayerParameter::exclude() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.exclude) + return exclude_; +} + +// optional .caffe.TransformationParameter transform_param = 100; +bool LayerParameter::has_transform_param() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void LayerParameter::set_has_transform_param() { + _has_bits_[0] |= 0x00000800u; +} +void LayerParameter::clear_has_transform_param() { + _has_bits_[0] &= ~0x00000800u; +} +void LayerParameter::clear_transform_param() { + if (transform_param_ != NULL) transform_param_->::caffe::TransformationParameter::Clear(); + clear_has_transform_param(); +} +const ::caffe::TransformationParameter& LayerParameter::transform_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.transform_param) + return transform_param_ != NULL ? *transform_param_ + : *::caffe::TransformationParameter::internal_default_instance(); +} +::caffe::TransformationParameter* LayerParameter::mutable_transform_param() { + set_has_transform_param(); + if (transform_param_ == NULL) { + transform_param_ = new ::caffe::TransformationParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.transform_param) + return transform_param_; +} +::caffe::TransformationParameter* LayerParameter::release_transform_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.transform_param) + clear_has_transform_param(); + ::caffe::TransformationParameter* temp = transform_param_; + transform_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_transform_param(::caffe::TransformationParameter* transform_param) { + delete transform_param_; + transform_param_ = transform_param; + if (transform_param) { + set_has_transform_param(); + } else { + clear_has_transform_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.transform_param) +} + +// optional .caffe.LossParameter loss_param = 101; +bool LayerParameter::has_loss_param() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +void LayerParameter::set_has_loss_param() { + _has_bits_[0] |= 0x00001000u; +} +void LayerParameter::clear_has_loss_param() { + _has_bits_[0] &= ~0x00001000u; +} +void LayerParameter::clear_loss_param() { + if (loss_param_ != NULL) loss_param_->::caffe::LossParameter::Clear(); + clear_has_loss_param(); +} +const ::caffe::LossParameter& LayerParameter::loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.loss_param) + return loss_param_ != NULL ? *loss_param_ + : *::caffe::LossParameter::internal_default_instance(); +} +::caffe::LossParameter* LayerParameter::mutable_loss_param() { + set_has_loss_param(); + if (loss_param_ == NULL) { + loss_param_ = new ::caffe::LossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.loss_param) + return loss_param_; +} +::caffe::LossParameter* LayerParameter::release_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.loss_param) + clear_has_loss_param(); + ::caffe::LossParameter* temp = loss_param_; + loss_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_loss_param(::caffe::LossParameter* loss_param) { + delete loss_param_; + loss_param_ = loss_param; + if (loss_param) { + set_has_loss_param(); + } else { + clear_has_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.loss_param) +} + +// optional .caffe.AccuracyParameter accuracy_param = 102; +bool LayerParameter::has_accuracy_param() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +void LayerParameter::set_has_accuracy_param() { + _has_bits_[0] |= 0x00002000u; +} +void LayerParameter::clear_has_accuracy_param() { + _has_bits_[0] &= ~0x00002000u; +} +void LayerParameter::clear_accuracy_param() { + if (accuracy_param_ != NULL) accuracy_param_->::caffe::AccuracyParameter::Clear(); + clear_has_accuracy_param(); +} +const ::caffe::AccuracyParameter& LayerParameter::accuracy_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.accuracy_param) + return accuracy_param_ != NULL ? *accuracy_param_ + : *::caffe::AccuracyParameter::internal_default_instance(); +} +::caffe::AccuracyParameter* LayerParameter::mutable_accuracy_param() { + set_has_accuracy_param(); + if (accuracy_param_ == NULL) { + accuracy_param_ = new ::caffe::AccuracyParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.accuracy_param) + return accuracy_param_; +} +::caffe::AccuracyParameter* LayerParameter::release_accuracy_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.accuracy_param) + clear_has_accuracy_param(); + ::caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param) { + delete accuracy_param_; + accuracy_param_ = accuracy_param; + if (accuracy_param) { + set_has_accuracy_param(); + } else { + clear_has_accuracy_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.accuracy_param) +} + +// optional .caffe.ArgMaxParameter argmax_param = 103; +bool LayerParameter::has_argmax_param() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +void LayerParameter::set_has_argmax_param() { + _has_bits_[0] |= 0x00004000u; +} +void LayerParameter::clear_has_argmax_param() { + _has_bits_[0] &= ~0x00004000u; +} +void LayerParameter::clear_argmax_param() { + if (argmax_param_ != NULL) argmax_param_->::caffe::ArgMaxParameter::Clear(); + clear_has_argmax_param(); +} +const ::caffe::ArgMaxParameter& LayerParameter::argmax_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.argmax_param) + return argmax_param_ != NULL ? *argmax_param_ + : *::caffe::ArgMaxParameter::internal_default_instance(); +} +::caffe::ArgMaxParameter* LayerParameter::mutable_argmax_param() { + set_has_argmax_param(); + if (argmax_param_ == NULL) { + argmax_param_ = new ::caffe::ArgMaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.argmax_param) + return argmax_param_; +} +::caffe::ArgMaxParameter* LayerParameter::release_argmax_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.argmax_param) + clear_has_argmax_param(); + ::caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param) { + delete argmax_param_; + argmax_param_ = argmax_param; + if (argmax_param) { + set_has_argmax_param(); + } else { + clear_has_argmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.argmax_param) +} + +// optional .caffe.BatchNormParameter batch_norm_param = 139; +bool LayerParameter::has_batch_norm_param() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +void LayerParameter::set_has_batch_norm_param() { + _has_bits_[0] |= 0x00008000u; +} +void LayerParameter::clear_has_batch_norm_param() { + _has_bits_[0] &= ~0x00008000u; +} +void LayerParameter::clear_batch_norm_param() { + if (batch_norm_param_ != NULL) batch_norm_param_->::caffe::BatchNormParameter::Clear(); + clear_has_batch_norm_param(); +} +const ::caffe::BatchNormParameter& LayerParameter::batch_norm_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.batch_norm_param) + return batch_norm_param_ != NULL ? *batch_norm_param_ + : *::caffe::BatchNormParameter::internal_default_instance(); +} +::caffe::BatchNormParameter* LayerParameter::mutable_batch_norm_param() { + set_has_batch_norm_param(); + if (batch_norm_param_ == NULL) { + batch_norm_param_ = new ::caffe::BatchNormParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.batch_norm_param) + return batch_norm_param_; +} +::caffe::BatchNormParameter* LayerParameter::release_batch_norm_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.batch_norm_param) + clear_has_batch_norm_param(); + ::caffe::BatchNormParameter* temp = batch_norm_param_; + batch_norm_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_batch_norm_param(::caffe::BatchNormParameter* batch_norm_param) { + delete batch_norm_param_; + batch_norm_param_ = batch_norm_param; + if (batch_norm_param) { + set_has_batch_norm_param(); + } else { + clear_has_batch_norm_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.batch_norm_param) +} + +// optional .caffe.BiasParameter bias_param = 141; +bool LayerParameter::has_bias_param() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +void LayerParameter::set_has_bias_param() { + _has_bits_[0] |= 0x00010000u; +} +void LayerParameter::clear_has_bias_param() { + _has_bits_[0] &= ~0x00010000u; +} +void LayerParameter::clear_bias_param() { + if (bias_param_ != NULL) bias_param_->::caffe::BiasParameter::Clear(); + clear_has_bias_param(); +} +const ::caffe::BiasParameter& LayerParameter::bias_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.bias_param) + return bias_param_ != NULL ? *bias_param_ + : *::caffe::BiasParameter::internal_default_instance(); +} +::caffe::BiasParameter* LayerParameter::mutable_bias_param() { + set_has_bias_param(); + if (bias_param_ == NULL) { + bias_param_ = new ::caffe::BiasParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.bias_param) + return bias_param_; +} +::caffe::BiasParameter* LayerParameter::release_bias_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.bias_param) + clear_has_bias_param(); + ::caffe::BiasParameter* temp = bias_param_; + bias_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_bias_param(::caffe::BiasParameter* bias_param) { + delete bias_param_; + bias_param_ = bias_param; + if (bias_param) { + set_has_bias_param(); + } else { + clear_has_bias_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.bias_param) +} + +// optional .caffe.ConcatParameter concat_param = 104; +bool LayerParameter::has_concat_param() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +void LayerParameter::set_has_concat_param() { + _has_bits_[0] |= 0x00020000u; +} +void LayerParameter::clear_has_concat_param() { + _has_bits_[0] &= ~0x00020000u; +} +void LayerParameter::clear_concat_param() { + if (concat_param_ != NULL) concat_param_->::caffe::ConcatParameter::Clear(); + clear_has_concat_param(); +} +const ::caffe::ConcatParameter& LayerParameter::concat_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.concat_param) + return concat_param_ != NULL ? *concat_param_ + : *::caffe::ConcatParameter::internal_default_instance(); +} +::caffe::ConcatParameter* LayerParameter::mutable_concat_param() { + set_has_concat_param(); + if (concat_param_ == NULL) { + concat_param_ = new ::caffe::ConcatParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.concat_param) + return concat_param_; +} +::caffe::ConcatParameter* LayerParameter::release_concat_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.concat_param) + clear_has_concat_param(); + ::caffe::ConcatParameter* temp = concat_param_; + concat_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_concat_param(::caffe::ConcatParameter* concat_param) { + delete concat_param_; + concat_param_ = concat_param; + if (concat_param) { + set_has_concat_param(); + } else { + clear_has_concat_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.concat_param) +} + +// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105; +bool LayerParameter::has_contrastive_loss_param() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +void LayerParameter::set_has_contrastive_loss_param() { + _has_bits_[0] |= 0x00040000u; +} +void LayerParameter::clear_has_contrastive_loss_param() { + _has_bits_[0] &= ~0x00040000u; +} +void LayerParameter::clear_contrastive_loss_param() { + if (contrastive_loss_param_ != NULL) contrastive_loss_param_->::caffe::ContrastiveLossParameter::Clear(); + clear_has_contrastive_loss_param(); +} +const ::caffe::ContrastiveLossParameter& LayerParameter::contrastive_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.contrastive_loss_param) + return contrastive_loss_param_ != NULL ? *contrastive_loss_param_ + : *::caffe::ContrastiveLossParameter::internal_default_instance(); +} +::caffe::ContrastiveLossParameter* LayerParameter::mutable_contrastive_loss_param() { + set_has_contrastive_loss_param(); + if (contrastive_loss_param_ == NULL) { + contrastive_loss_param_ = new ::caffe::ContrastiveLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.contrastive_loss_param) + return contrastive_loss_param_; +} +::caffe::ContrastiveLossParameter* LayerParameter::release_contrastive_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.contrastive_loss_param) + clear_has_contrastive_loss_param(); + ::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param) { + delete contrastive_loss_param_; + contrastive_loss_param_ = contrastive_loss_param; + if (contrastive_loss_param) { + set_has_contrastive_loss_param(); + } else { + clear_has_contrastive_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.contrastive_loss_param) +} + +// optional .caffe.ConvolutionParameter convolution_param = 106; +bool LayerParameter::has_convolution_param() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +void LayerParameter::set_has_convolution_param() { + _has_bits_[0] |= 0x00080000u; +} +void LayerParameter::clear_has_convolution_param() { + _has_bits_[0] &= ~0x00080000u; +} +void LayerParameter::clear_convolution_param() { + if (convolution_param_ != NULL) convolution_param_->::caffe::ConvolutionParameter::Clear(); + clear_has_convolution_param(); +} +const ::caffe::ConvolutionParameter& LayerParameter::convolution_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.convolution_param) + return convolution_param_ != NULL ? *convolution_param_ + : *::caffe::ConvolutionParameter::internal_default_instance(); +} +::caffe::ConvolutionParameter* LayerParameter::mutable_convolution_param() { + set_has_convolution_param(); + if (convolution_param_ == NULL) { + convolution_param_ = new ::caffe::ConvolutionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.convolution_param) + return convolution_param_; +} +::caffe::ConvolutionParameter* LayerParameter::release_convolution_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.convolution_param) + clear_has_convolution_param(); + ::caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param) { + delete convolution_param_; + convolution_param_ = convolution_param; + if (convolution_param) { + set_has_convolution_param(); + } else { + clear_has_convolution_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.convolution_param) +} + +// optional .caffe.CropParameter crop_param = 144; +bool LayerParameter::has_crop_param() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +void LayerParameter::set_has_crop_param() { + _has_bits_[0] |= 0x00100000u; +} +void LayerParameter::clear_has_crop_param() { + _has_bits_[0] &= ~0x00100000u; +} +void LayerParameter::clear_crop_param() { + if (crop_param_ != NULL) crop_param_->::caffe::CropParameter::Clear(); + clear_has_crop_param(); +} +const ::caffe::CropParameter& LayerParameter::crop_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.crop_param) + return crop_param_ != NULL ? *crop_param_ + : *::caffe::CropParameter::internal_default_instance(); +} +::caffe::CropParameter* LayerParameter::mutable_crop_param() { + set_has_crop_param(); + if (crop_param_ == NULL) { + crop_param_ = new ::caffe::CropParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.crop_param) + return crop_param_; +} +::caffe::CropParameter* LayerParameter::release_crop_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.crop_param) + clear_has_crop_param(); + ::caffe::CropParameter* temp = crop_param_; + crop_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_crop_param(::caffe::CropParameter* crop_param) { + delete crop_param_; + crop_param_ = crop_param; + if (crop_param) { + set_has_crop_param(); + } else { + clear_has_crop_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.crop_param) +} + +// optional .caffe.DataParameter data_param = 107; +bool LayerParameter::has_data_param() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +void LayerParameter::set_has_data_param() { + _has_bits_[0] |= 0x00200000u; +} +void LayerParameter::clear_has_data_param() { + _has_bits_[0] &= ~0x00200000u; +} +void LayerParameter::clear_data_param() { + if (data_param_ != NULL) data_param_->::caffe::DataParameter::Clear(); + clear_has_data_param(); +} +const ::caffe::DataParameter& LayerParameter::data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.data_param) + return data_param_ != NULL ? *data_param_ + : *::caffe::DataParameter::internal_default_instance(); +} +::caffe::DataParameter* LayerParameter::mutable_data_param() { + set_has_data_param(); + if (data_param_ == NULL) { + data_param_ = new ::caffe::DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.data_param) + return data_param_; +} +::caffe::DataParameter* LayerParameter::release_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.data_param) + clear_has_data_param(); + ::caffe::DataParameter* temp = data_param_; + data_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_data_param(::caffe::DataParameter* data_param) { + delete data_param_; + data_param_ = data_param; + if (data_param) { + set_has_data_param(); + } else { + clear_has_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.data_param) +} + +// optional .caffe.DetectionOutputParameter detection_output_param = 147; +bool LayerParameter::has_detection_output_param() const { + return (_has_bits_[0] & 0x00400000u) != 0; +} +void LayerParameter::set_has_detection_output_param() { + _has_bits_[0] |= 0x00400000u; +} +void LayerParameter::clear_has_detection_output_param() { + _has_bits_[0] &= ~0x00400000u; +} +void LayerParameter::clear_detection_output_param() { + if (detection_output_param_ != NULL) detection_output_param_->::caffe::DetectionOutputParameter::Clear(); + clear_has_detection_output_param(); +} +const ::caffe::DetectionOutputParameter& LayerParameter::detection_output_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.detection_output_param) + return detection_output_param_ != NULL ? *detection_output_param_ + : *::caffe::DetectionOutputParameter::internal_default_instance(); +} +::caffe::DetectionOutputParameter* LayerParameter::mutable_detection_output_param() { + set_has_detection_output_param(); + if (detection_output_param_ == NULL) { + detection_output_param_ = new ::caffe::DetectionOutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.detection_output_param) + return detection_output_param_; +} +::caffe::DetectionOutputParameter* LayerParameter::release_detection_output_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.detection_output_param) + clear_has_detection_output_param(); + ::caffe::DetectionOutputParameter* temp = detection_output_param_; + detection_output_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_detection_output_param(::caffe::DetectionOutputParameter* detection_output_param) { + delete detection_output_param_; + detection_output_param_ = detection_output_param; + if (detection_output_param) { + set_has_detection_output_param(); + } else { + clear_has_detection_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.detection_output_param) +} + +// optional .caffe.DropoutParameter dropout_param = 108; +bool LayerParameter::has_dropout_param() const { + return (_has_bits_[0] & 0x00800000u) != 0; +} +void LayerParameter::set_has_dropout_param() { + _has_bits_[0] |= 0x00800000u; +} +void LayerParameter::clear_has_dropout_param() { + _has_bits_[0] &= ~0x00800000u; +} +void LayerParameter::clear_dropout_param() { + if (dropout_param_ != NULL) dropout_param_->::caffe::DropoutParameter::Clear(); + clear_has_dropout_param(); +} +const ::caffe::DropoutParameter& LayerParameter::dropout_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.dropout_param) + return dropout_param_ != NULL ? *dropout_param_ + : *::caffe::DropoutParameter::internal_default_instance(); +} +::caffe::DropoutParameter* LayerParameter::mutable_dropout_param() { + set_has_dropout_param(); + if (dropout_param_ == NULL) { + dropout_param_ = new ::caffe::DropoutParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.dropout_param) + return dropout_param_; +} +::caffe::DropoutParameter* LayerParameter::release_dropout_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.dropout_param) + clear_has_dropout_param(); + ::caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param) { + delete dropout_param_; + dropout_param_ = dropout_param; + if (dropout_param) { + set_has_dropout_param(); + } else { + clear_has_dropout_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.dropout_param) +} + +// optional .caffe.DummyDataParameter dummy_data_param = 109; +bool LayerParameter::has_dummy_data_param() const { + return (_has_bits_[0] & 0x01000000u) != 0; +} +void LayerParameter::set_has_dummy_data_param() { + _has_bits_[0] |= 0x01000000u; +} +void LayerParameter::clear_has_dummy_data_param() { + _has_bits_[0] &= ~0x01000000u; +} +void LayerParameter::clear_dummy_data_param() { + if (dummy_data_param_ != NULL) dummy_data_param_->::caffe::DummyDataParameter::Clear(); + clear_has_dummy_data_param(); +} +const ::caffe::DummyDataParameter& LayerParameter::dummy_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.dummy_data_param) + return dummy_data_param_ != NULL ? *dummy_data_param_ + : *::caffe::DummyDataParameter::internal_default_instance(); +} +::caffe::DummyDataParameter* LayerParameter::mutable_dummy_data_param() { + set_has_dummy_data_param(); + if (dummy_data_param_ == NULL) { + dummy_data_param_ = new ::caffe::DummyDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.dummy_data_param) + return dummy_data_param_; +} +::caffe::DummyDataParameter* LayerParameter::release_dummy_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.dummy_data_param) + clear_has_dummy_data_param(); + ::caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param) { + delete dummy_data_param_; + dummy_data_param_ = dummy_data_param; + if (dummy_data_param) { + set_has_dummy_data_param(); + } else { + clear_has_dummy_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.dummy_data_param) +} + +// optional .caffe.EltwiseParameter eltwise_param = 110; +bool LayerParameter::has_eltwise_param() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +void LayerParameter::set_has_eltwise_param() { + _has_bits_[0] |= 0x02000000u; +} +void LayerParameter::clear_has_eltwise_param() { + _has_bits_[0] &= ~0x02000000u; +} +void LayerParameter::clear_eltwise_param() { + if (eltwise_param_ != NULL) eltwise_param_->::caffe::EltwiseParameter::Clear(); + clear_has_eltwise_param(); +} +const ::caffe::EltwiseParameter& LayerParameter::eltwise_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.eltwise_param) + return eltwise_param_ != NULL ? *eltwise_param_ + : *::caffe::EltwiseParameter::internal_default_instance(); +} +::caffe::EltwiseParameter* LayerParameter::mutable_eltwise_param() { + set_has_eltwise_param(); + if (eltwise_param_ == NULL) { + eltwise_param_ = new ::caffe::EltwiseParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.eltwise_param) + return eltwise_param_; +} +::caffe::EltwiseParameter* LayerParameter::release_eltwise_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.eltwise_param) + clear_has_eltwise_param(); + ::caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param) { + delete eltwise_param_; + eltwise_param_ = eltwise_param; + if (eltwise_param) { + set_has_eltwise_param(); + } else { + clear_has_eltwise_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.eltwise_param) +} + +// optional .caffe.ELUParameter elu_param = 140; +bool LayerParameter::has_elu_param() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +void LayerParameter::set_has_elu_param() { + _has_bits_[0] |= 0x04000000u; +} +void LayerParameter::clear_has_elu_param() { + _has_bits_[0] &= ~0x04000000u; +} +void LayerParameter::clear_elu_param() { + if (elu_param_ != NULL) elu_param_->::caffe::ELUParameter::Clear(); + clear_has_elu_param(); +} +const ::caffe::ELUParameter& LayerParameter::elu_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.elu_param) + return elu_param_ != NULL ? *elu_param_ + : *::caffe::ELUParameter::internal_default_instance(); +} +::caffe::ELUParameter* LayerParameter::mutable_elu_param() { + set_has_elu_param(); + if (elu_param_ == NULL) { + elu_param_ = new ::caffe::ELUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.elu_param) + return elu_param_; +} +::caffe::ELUParameter* LayerParameter::release_elu_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.elu_param) + clear_has_elu_param(); + ::caffe::ELUParameter* temp = elu_param_; + elu_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_elu_param(::caffe::ELUParameter* elu_param) { + delete elu_param_; + elu_param_ = elu_param; + if (elu_param) { + set_has_elu_param(); + } else { + clear_has_elu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.elu_param) +} + +// optional .caffe.EmbedParameter embed_param = 137; +bool LayerParameter::has_embed_param() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +void LayerParameter::set_has_embed_param() { + _has_bits_[0] |= 0x08000000u; +} +void LayerParameter::clear_has_embed_param() { + _has_bits_[0] &= ~0x08000000u; +} +void LayerParameter::clear_embed_param() { + if (embed_param_ != NULL) embed_param_->::caffe::EmbedParameter::Clear(); + clear_has_embed_param(); +} +const ::caffe::EmbedParameter& LayerParameter::embed_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.embed_param) + return embed_param_ != NULL ? *embed_param_ + : *::caffe::EmbedParameter::internal_default_instance(); +} +::caffe::EmbedParameter* LayerParameter::mutable_embed_param() { + set_has_embed_param(); + if (embed_param_ == NULL) { + embed_param_ = new ::caffe::EmbedParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.embed_param) + return embed_param_; +} +::caffe::EmbedParameter* LayerParameter::release_embed_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.embed_param) + clear_has_embed_param(); + ::caffe::EmbedParameter* temp = embed_param_; + embed_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_embed_param(::caffe::EmbedParameter* embed_param) { + delete embed_param_; + embed_param_ = embed_param; + if (embed_param) { + set_has_embed_param(); + } else { + clear_has_embed_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.embed_param) +} + +// optional .caffe.ExpParameter exp_param = 111; +bool LayerParameter::has_exp_param() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +void LayerParameter::set_has_exp_param() { + _has_bits_[0] |= 0x10000000u; +} +void LayerParameter::clear_has_exp_param() { + _has_bits_[0] &= ~0x10000000u; +} +void LayerParameter::clear_exp_param() { + if (exp_param_ != NULL) exp_param_->::caffe::ExpParameter::Clear(); + clear_has_exp_param(); +} +const ::caffe::ExpParameter& LayerParameter::exp_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.exp_param) + return exp_param_ != NULL ? *exp_param_ + : *::caffe::ExpParameter::internal_default_instance(); +} +::caffe::ExpParameter* LayerParameter::mutable_exp_param() { + set_has_exp_param(); + if (exp_param_ == NULL) { + exp_param_ = new ::caffe::ExpParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.exp_param) + return exp_param_; +} +::caffe::ExpParameter* LayerParameter::release_exp_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.exp_param) + clear_has_exp_param(); + ::caffe::ExpParameter* temp = exp_param_; + exp_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_exp_param(::caffe::ExpParameter* exp_param) { + delete exp_param_; + exp_param_ = exp_param; + if (exp_param) { + set_has_exp_param(); + } else { + clear_has_exp_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.exp_param) +} + +// optional .caffe.FlattenParameter flatten_param = 135; +bool LayerParameter::has_flatten_param() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +void LayerParameter::set_has_flatten_param() { + _has_bits_[0] |= 0x20000000u; +} +void LayerParameter::clear_has_flatten_param() { + _has_bits_[0] &= ~0x20000000u; +} +void LayerParameter::clear_flatten_param() { + if (flatten_param_ != NULL) flatten_param_->::caffe::FlattenParameter::Clear(); + clear_has_flatten_param(); +} +const ::caffe::FlattenParameter& LayerParameter::flatten_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.flatten_param) + return flatten_param_ != NULL ? *flatten_param_ + : *::caffe::FlattenParameter::internal_default_instance(); +} +::caffe::FlattenParameter* LayerParameter::mutable_flatten_param() { + set_has_flatten_param(); + if (flatten_param_ == NULL) { + flatten_param_ = new ::caffe::FlattenParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.flatten_param) + return flatten_param_; +} +::caffe::FlattenParameter* LayerParameter::release_flatten_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.flatten_param) + clear_has_flatten_param(); + ::caffe::FlattenParameter* temp = flatten_param_; + flatten_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_flatten_param(::caffe::FlattenParameter* flatten_param) { + delete flatten_param_; + flatten_param_ = flatten_param; + if (flatten_param) { + set_has_flatten_param(); + } else { + clear_has_flatten_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.flatten_param) +} + +// optional .caffe.HDF5DataParameter hdf5_data_param = 112; +bool LayerParameter::has_hdf5_data_param() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +void LayerParameter::set_has_hdf5_data_param() { + _has_bits_[0] |= 0x40000000u; +} +void LayerParameter::clear_has_hdf5_data_param() { + _has_bits_[0] &= ~0x40000000u; +} +void LayerParameter::clear_hdf5_data_param() { + if (hdf5_data_param_ != NULL) hdf5_data_param_->::caffe::HDF5DataParameter::Clear(); + clear_has_hdf5_data_param(); +} +const ::caffe::HDF5DataParameter& LayerParameter::hdf5_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.hdf5_data_param) + return hdf5_data_param_ != NULL ? *hdf5_data_param_ + : *::caffe::HDF5DataParameter::internal_default_instance(); +} +::caffe::HDF5DataParameter* LayerParameter::mutable_hdf5_data_param() { + set_has_hdf5_data_param(); + if (hdf5_data_param_ == NULL) { + hdf5_data_param_ = new ::caffe::HDF5DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hdf5_data_param) + return hdf5_data_param_; +} +::caffe::HDF5DataParameter* LayerParameter::release_hdf5_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.hdf5_data_param) + clear_has_hdf5_data_param(); + ::caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param) { + delete hdf5_data_param_; + hdf5_data_param_ = hdf5_data_param; + if (hdf5_data_param) { + set_has_hdf5_data_param(); + } else { + clear_has_hdf5_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hdf5_data_param) +} + +// optional .caffe.HDF5OutputParameter hdf5_output_param = 113; +bool LayerParameter::has_hdf5_output_param() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +void LayerParameter::set_has_hdf5_output_param() { + _has_bits_[0] |= 0x80000000u; +} +void LayerParameter::clear_has_hdf5_output_param() { + _has_bits_[0] &= ~0x80000000u; +} +void LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + clear_has_hdf5_output_param(); +} +const ::caffe::HDF5OutputParameter& LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.hdf5_output_param) + return hdf5_output_param_ != NULL ? *hdf5_output_param_ + : *::caffe::HDF5OutputParameter::internal_default_instance(); +} +::caffe::HDF5OutputParameter* LayerParameter::mutable_hdf5_output_param() { + set_has_hdf5_output_param(); + if (hdf5_output_param_ == NULL) { + hdf5_output_param_ = new ::caffe::HDF5OutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hdf5_output_param) + return hdf5_output_param_; +} +::caffe::HDF5OutputParameter* LayerParameter::release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.hdf5_output_param) + clear_has_hdf5_output_param(); + ::caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) { + delete hdf5_output_param_; + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + set_has_hdf5_output_param(); + } else { + clear_has_hdf5_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hdf5_output_param) +} + +// optional .caffe.HingeLossParameter hinge_loss_param = 114; +bool LayerParameter::has_hinge_loss_param() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +void LayerParameter::set_has_hinge_loss_param() { + _has_bits_[1] |= 0x00000001u; +} +void LayerParameter::clear_has_hinge_loss_param() { + _has_bits_[1] &= ~0x00000001u; +} +void LayerParameter::clear_hinge_loss_param() { + if (hinge_loss_param_ != NULL) hinge_loss_param_->::caffe::HingeLossParameter::Clear(); + clear_has_hinge_loss_param(); +} +const ::caffe::HingeLossParameter& LayerParameter::hinge_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.hinge_loss_param) + return hinge_loss_param_ != NULL ? *hinge_loss_param_ + : *::caffe::HingeLossParameter::internal_default_instance(); +} +::caffe::HingeLossParameter* LayerParameter::mutable_hinge_loss_param() { + set_has_hinge_loss_param(); + if (hinge_loss_param_ == NULL) { + hinge_loss_param_ = new ::caffe::HingeLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hinge_loss_param) + return hinge_loss_param_; +} +::caffe::HingeLossParameter* LayerParameter::release_hinge_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.hinge_loss_param) + clear_has_hinge_loss_param(); + ::caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param) { + delete hinge_loss_param_; + hinge_loss_param_ = hinge_loss_param; + if (hinge_loss_param) { + set_has_hinge_loss_param(); + } else { + clear_has_hinge_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hinge_loss_param) +} + +// optional .caffe.ImageDataParameter image_data_param = 115; +bool LayerParameter::has_image_data_param() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +void LayerParameter::set_has_image_data_param() { + _has_bits_[1] |= 0x00000002u; +} +void LayerParameter::clear_has_image_data_param() { + _has_bits_[1] &= ~0x00000002u; +} +void LayerParameter::clear_image_data_param() { + if (image_data_param_ != NULL) image_data_param_->::caffe::ImageDataParameter::Clear(); + clear_has_image_data_param(); +} +const ::caffe::ImageDataParameter& LayerParameter::image_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.image_data_param) + return image_data_param_ != NULL ? *image_data_param_ + : *::caffe::ImageDataParameter::internal_default_instance(); +} +::caffe::ImageDataParameter* LayerParameter::mutable_image_data_param() { + set_has_image_data_param(); + if (image_data_param_ == NULL) { + image_data_param_ = new ::caffe::ImageDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.image_data_param) + return image_data_param_; +} +::caffe::ImageDataParameter* LayerParameter::release_image_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.image_data_param) + clear_has_image_data_param(); + ::caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param) { + delete image_data_param_; + image_data_param_ = image_data_param; + if (image_data_param) { + set_has_image_data_param(); + } else { + clear_has_image_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.image_data_param) +} + +// optional .caffe.InfogainLossParameter infogain_loss_param = 116; +bool LayerParameter::has_infogain_loss_param() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +void LayerParameter::set_has_infogain_loss_param() { + _has_bits_[1] |= 0x00000004u; +} +void LayerParameter::clear_has_infogain_loss_param() { + _has_bits_[1] &= ~0x00000004u; +} +void LayerParameter::clear_infogain_loss_param() { + if (infogain_loss_param_ != NULL) infogain_loss_param_->::caffe::InfogainLossParameter::Clear(); + clear_has_infogain_loss_param(); +} +const ::caffe::InfogainLossParameter& LayerParameter::infogain_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.infogain_loss_param) + return infogain_loss_param_ != NULL ? *infogain_loss_param_ + : *::caffe::InfogainLossParameter::internal_default_instance(); +} +::caffe::InfogainLossParameter* LayerParameter::mutable_infogain_loss_param() { + set_has_infogain_loss_param(); + if (infogain_loss_param_ == NULL) { + infogain_loss_param_ = new ::caffe::InfogainLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.infogain_loss_param) + return infogain_loss_param_; +} +::caffe::InfogainLossParameter* LayerParameter::release_infogain_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.infogain_loss_param) + clear_has_infogain_loss_param(); + ::caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param) { + delete infogain_loss_param_; + infogain_loss_param_ = infogain_loss_param; + if (infogain_loss_param) { + set_has_infogain_loss_param(); + } else { + clear_has_infogain_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.infogain_loss_param) +} + +// optional .caffe.InnerProductParameter inner_product_param = 117; +bool LayerParameter::has_inner_product_param() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +void LayerParameter::set_has_inner_product_param() { + _has_bits_[1] |= 0x00000008u; +} +void LayerParameter::clear_has_inner_product_param() { + _has_bits_[1] &= ~0x00000008u; +} +void LayerParameter::clear_inner_product_param() { + if (inner_product_param_ != NULL) inner_product_param_->::caffe::InnerProductParameter::Clear(); + clear_has_inner_product_param(); +} +const ::caffe::InnerProductParameter& LayerParameter::inner_product_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.inner_product_param) + return inner_product_param_ != NULL ? *inner_product_param_ + : *::caffe::InnerProductParameter::internal_default_instance(); +} +::caffe::InnerProductParameter* LayerParameter::mutable_inner_product_param() { + set_has_inner_product_param(); + if (inner_product_param_ == NULL) { + inner_product_param_ = new ::caffe::InnerProductParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.inner_product_param) + return inner_product_param_; +} +::caffe::InnerProductParameter* LayerParameter::release_inner_product_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.inner_product_param) + clear_has_inner_product_param(); + ::caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param) { + delete inner_product_param_; + inner_product_param_ = inner_product_param; + if (inner_product_param) { + set_has_inner_product_param(); + } else { + clear_has_inner_product_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.inner_product_param) +} + +// optional .caffe.InputParameter input_param = 143; +bool LayerParameter::has_input_param() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +void LayerParameter::set_has_input_param() { + _has_bits_[1] |= 0x00000010u; +} +void LayerParameter::clear_has_input_param() { + _has_bits_[1] &= ~0x00000010u; +} +void LayerParameter::clear_input_param() { + if (input_param_ != NULL) input_param_->::caffe::InputParameter::Clear(); + clear_has_input_param(); +} +const ::caffe::InputParameter& LayerParameter::input_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.input_param) + return input_param_ != NULL ? *input_param_ + : *::caffe::InputParameter::internal_default_instance(); +} +::caffe::InputParameter* LayerParameter::mutable_input_param() { + set_has_input_param(); + if (input_param_ == NULL) { + input_param_ = new ::caffe::InputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.input_param) + return input_param_; +} +::caffe::InputParameter* LayerParameter::release_input_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.input_param) + clear_has_input_param(); + ::caffe::InputParameter* temp = input_param_; + input_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_input_param(::caffe::InputParameter* input_param) { + delete input_param_; + input_param_ = input_param; + if (input_param) { + set_has_input_param(); + } else { + clear_has_input_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.input_param) +} + +// optional .caffe.LogParameter log_param = 134; +bool LayerParameter::has_log_param() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +void LayerParameter::set_has_log_param() { + _has_bits_[1] |= 0x00000020u; +} +void LayerParameter::clear_has_log_param() { + _has_bits_[1] &= ~0x00000020u; +} +void LayerParameter::clear_log_param() { + if (log_param_ != NULL) log_param_->::caffe::LogParameter::Clear(); + clear_has_log_param(); +} +const ::caffe::LogParameter& LayerParameter::log_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.log_param) + return log_param_ != NULL ? *log_param_ + : *::caffe::LogParameter::internal_default_instance(); +} +::caffe::LogParameter* LayerParameter::mutable_log_param() { + set_has_log_param(); + if (log_param_ == NULL) { + log_param_ = new ::caffe::LogParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.log_param) + return log_param_; +} +::caffe::LogParameter* LayerParameter::release_log_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.log_param) + clear_has_log_param(); + ::caffe::LogParameter* temp = log_param_; + log_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_log_param(::caffe::LogParameter* log_param) { + delete log_param_; + log_param_ = log_param; + if (log_param) { + set_has_log_param(); + } else { + clear_has_log_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.log_param) +} + +// optional .caffe.LRNParameter lrn_param = 118; +bool LayerParameter::has_lrn_param() const { + return (_has_bits_[1] & 0x00000040u) != 0; +} +void LayerParameter::set_has_lrn_param() { + _has_bits_[1] |= 0x00000040u; +} +void LayerParameter::clear_has_lrn_param() { + _has_bits_[1] &= ~0x00000040u; +} +void LayerParameter::clear_lrn_param() { + if (lrn_param_ != NULL) lrn_param_->::caffe::LRNParameter::Clear(); + clear_has_lrn_param(); +} +const ::caffe::LRNParameter& LayerParameter::lrn_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.lrn_param) + return lrn_param_ != NULL ? *lrn_param_ + : *::caffe::LRNParameter::internal_default_instance(); +} +::caffe::LRNParameter* LayerParameter::mutable_lrn_param() { + set_has_lrn_param(); + if (lrn_param_ == NULL) { + lrn_param_ = new ::caffe::LRNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.lrn_param) + return lrn_param_; +} +::caffe::LRNParameter* LayerParameter::release_lrn_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.lrn_param) + clear_has_lrn_param(); + ::caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_lrn_param(::caffe::LRNParameter* lrn_param) { + delete lrn_param_; + lrn_param_ = lrn_param; + if (lrn_param) { + set_has_lrn_param(); + } else { + clear_has_lrn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.lrn_param) +} + +// optional .caffe.MemoryDataParameter memory_data_param = 119; +bool LayerParameter::has_memory_data_param() const { + return (_has_bits_[1] & 0x00000080u) != 0; +} +void LayerParameter::set_has_memory_data_param() { + _has_bits_[1] |= 0x00000080u; +} +void LayerParameter::clear_has_memory_data_param() { + _has_bits_[1] &= ~0x00000080u; +} +void LayerParameter::clear_memory_data_param() { + if (memory_data_param_ != NULL) memory_data_param_->::caffe::MemoryDataParameter::Clear(); + clear_has_memory_data_param(); +} +const ::caffe::MemoryDataParameter& LayerParameter::memory_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.memory_data_param) + return memory_data_param_ != NULL ? *memory_data_param_ + : *::caffe::MemoryDataParameter::internal_default_instance(); +} +::caffe::MemoryDataParameter* LayerParameter::mutable_memory_data_param() { + set_has_memory_data_param(); + if (memory_data_param_ == NULL) { + memory_data_param_ = new ::caffe::MemoryDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.memory_data_param) + return memory_data_param_; +} +::caffe::MemoryDataParameter* LayerParameter::release_memory_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.memory_data_param) + clear_has_memory_data_param(); + ::caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param) { + delete memory_data_param_; + memory_data_param_ = memory_data_param; + if (memory_data_param) { + set_has_memory_data_param(); + } else { + clear_has_memory_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.memory_data_param) +} + +// optional .caffe.MVNParameter mvn_param = 120; +bool LayerParameter::has_mvn_param() const { + return (_has_bits_[1] & 0x00000100u) != 0; +} +void LayerParameter::set_has_mvn_param() { + _has_bits_[1] |= 0x00000100u; +} +void LayerParameter::clear_has_mvn_param() { + _has_bits_[1] &= ~0x00000100u; +} +void LayerParameter::clear_mvn_param() { + if (mvn_param_ != NULL) mvn_param_->::caffe::MVNParameter::Clear(); + clear_has_mvn_param(); +} +const ::caffe::MVNParameter& LayerParameter::mvn_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.mvn_param) + return mvn_param_ != NULL ? *mvn_param_ + : *::caffe::MVNParameter::internal_default_instance(); +} +::caffe::MVNParameter* LayerParameter::mutable_mvn_param() { + set_has_mvn_param(); + if (mvn_param_ == NULL) { + mvn_param_ = new ::caffe::MVNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.mvn_param) + return mvn_param_; +} +::caffe::MVNParameter* LayerParameter::release_mvn_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.mvn_param) + clear_has_mvn_param(); + ::caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_mvn_param(::caffe::MVNParameter* mvn_param) { + delete mvn_param_; + mvn_param_ = mvn_param; + if (mvn_param) { + set_has_mvn_param(); + } else { + clear_has_mvn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.mvn_param) +} + +// optional .caffe.NormalizeBBoxParameter norm_param = 149; +bool LayerParameter::has_norm_param() const { + return (_has_bits_[1] & 0x00000200u) != 0; +} +void LayerParameter::set_has_norm_param() { + _has_bits_[1] |= 0x00000200u; +} +void LayerParameter::clear_has_norm_param() { + _has_bits_[1] &= ~0x00000200u; +} +void LayerParameter::clear_norm_param() { + if (norm_param_ != NULL) norm_param_->::caffe::NormalizeBBoxParameter::Clear(); + clear_has_norm_param(); +} +const ::caffe::NormalizeBBoxParameter& LayerParameter::norm_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.norm_param) + return norm_param_ != NULL ? *norm_param_ + : *::caffe::NormalizeBBoxParameter::internal_default_instance(); +} +::caffe::NormalizeBBoxParameter* LayerParameter::mutable_norm_param() { + set_has_norm_param(); + if (norm_param_ == NULL) { + norm_param_ = new ::caffe::NormalizeBBoxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.norm_param) + return norm_param_; +} +::caffe::NormalizeBBoxParameter* LayerParameter::release_norm_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.norm_param) + clear_has_norm_param(); + ::caffe::NormalizeBBoxParameter* temp = norm_param_; + norm_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_norm_param(::caffe::NormalizeBBoxParameter* norm_param) { + delete norm_param_; + norm_param_ = norm_param; + if (norm_param) { + set_has_norm_param(); + } else { + clear_has_norm_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.norm_param) +} + +// optional .caffe.PermuteParameter permute_param = 148; +bool LayerParameter::has_permute_param() const { + return (_has_bits_[1] & 0x00000400u) != 0; +} +void LayerParameter::set_has_permute_param() { + _has_bits_[1] |= 0x00000400u; +} +void LayerParameter::clear_has_permute_param() { + _has_bits_[1] &= ~0x00000400u; +} +void LayerParameter::clear_permute_param() { + if (permute_param_ != NULL) permute_param_->::caffe::PermuteParameter::Clear(); + clear_has_permute_param(); +} +const ::caffe::PermuteParameter& LayerParameter::permute_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.permute_param) + return permute_param_ != NULL ? *permute_param_ + : *::caffe::PermuteParameter::internal_default_instance(); +} +::caffe::PermuteParameter* LayerParameter::mutable_permute_param() { + set_has_permute_param(); + if (permute_param_ == NULL) { + permute_param_ = new ::caffe::PermuteParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.permute_param) + return permute_param_; +} +::caffe::PermuteParameter* LayerParameter::release_permute_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.permute_param) + clear_has_permute_param(); + ::caffe::PermuteParameter* temp = permute_param_; + permute_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_permute_param(::caffe::PermuteParameter* permute_param) { + delete permute_param_; + permute_param_ = permute_param; + if (permute_param) { + set_has_permute_param(); + } else { + clear_has_permute_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.permute_param) +} + +// optional .caffe.ParameterParameter parameter_param = 145; +bool LayerParameter::has_parameter_param() const { + return (_has_bits_[1] & 0x00000800u) != 0; +} +void LayerParameter::set_has_parameter_param() { + _has_bits_[1] |= 0x00000800u; +} +void LayerParameter::clear_has_parameter_param() { + _has_bits_[1] &= ~0x00000800u; +} +void LayerParameter::clear_parameter_param() { + if (parameter_param_ != NULL) parameter_param_->::caffe::ParameterParameter::Clear(); + clear_has_parameter_param(); +} +const ::caffe::ParameterParameter& LayerParameter::parameter_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.parameter_param) + return parameter_param_ != NULL ? *parameter_param_ + : *::caffe::ParameterParameter::internal_default_instance(); +} +::caffe::ParameterParameter* LayerParameter::mutable_parameter_param() { + set_has_parameter_param(); + if (parameter_param_ == NULL) { + parameter_param_ = new ::caffe::ParameterParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.parameter_param) + return parameter_param_; +} +::caffe::ParameterParameter* LayerParameter::release_parameter_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.parameter_param) + clear_has_parameter_param(); + ::caffe::ParameterParameter* temp = parameter_param_; + parameter_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_parameter_param(::caffe::ParameterParameter* parameter_param) { + delete parameter_param_; + parameter_param_ = parameter_param; + if (parameter_param) { + set_has_parameter_param(); + } else { + clear_has_parameter_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.parameter_param) +} + +// optional .caffe.PoolingParameter pooling_param = 121; +bool LayerParameter::has_pooling_param() const { + return (_has_bits_[1] & 0x00001000u) != 0; +} +void LayerParameter::set_has_pooling_param() { + _has_bits_[1] |= 0x00001000u; +} +void LayerParameter::clear_has_pooling_param() { + _has_bits_[1] &= ~0x00001000u; +} +void LayerParameter::clear_pooling_param() { + if (pooling_param_ != NULL) pooling_param_->::caffe::PoolingParameter::Clear(); + clear_has_pooling_param(); +} +const ::caffe::PoolingParameter& LayerParameter::pooling_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.pooling_param) + return pooling_param_ != NULL ? *pooling_param_ + : *::caffe::PoolingParameter::internal_default_instance(); +} +::caffe::PoolingParameter* LayerParameter::mutable_pooling_param() { + set_has_pooling_param(); + if (pooling_param_ == NULL) { + pooling_param_ = new ::caffe::PoolingParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.pooling_param) + return pooling_param_; +} +::caffe::PoolingParameter* LayerParameter::release_pooling_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.pooling_param) + clear_has_pooling_param(); + ::caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param) { + delete pooling_param_; + pooling_param_ = pooling_param; + if (pooling_param) { + set_has_pooling_param(); + } else { + clear_has_pooling_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.pooling_param) +} + +// optional .caffe.PowerParameter power_param = 122; +bool LayerParameter::has_power_param() const { + return (_has_bits_[1] & 0x00002000u) != 0; +} +void LayerParameter::set_has_power_param() { + _has_bits_[1] |= 0x00002000u; +} +void LayerParameter::clear_has_power_param() { + _has_bits_[1] &= ~0x00002000u; +} +void LayerParameter::clear_power_param() { + if (power_param_ != NULL) power_param_->::caffe::PowerParameter::Clear(); + clear_has_power_param(); +} +const ::caffe::PowerParameter& LayerParameter::power_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.power_param) + return power_param_ != NULL ? *power_param_ + : *::caffe::PowerParameter::internal_default_instance(); +} +::caffe::PowerParameter* LayerParameter::mutable_power_param() { + set_has_power_param(); + if (power_param_ == NULL) { + power_param_ = new ::caffe::PowerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.power_param) + return power_param_; +} +::caffe::PowerParameter* LayerParameter::release_power_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.power_param) + clear_has_power_param(); + ::caffe::PowerParameter* temp = power_param_; + power_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_power_param(::caffe::PowerParameter* power_param) { + delete power_param_; + power_param_ = power_param; + if (power_param) { + set_has_power_param(); + } else { + clear_has_power_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.power_param) +} + +// optional .caffe.PReLUParameter prelu_param = 131; +bool LayerParameter::has_prelu_param() const { + return (_has_bits_[1] & 0x00004000u) != 0; +} +void LayerParameter::set_has_prelu_param() { + _has_bits_[1] |= 0x00004000u; +} +void LayerParameter::clear_has_prelu_param() { + _has_bits_[1] &= ~0x00004000u; +} +void LayerParameter::clear_prelu_param() { + if (prelu_param_ != NULL) prelu_param_->::caffe::PReLUParameter::Clear(); + clear_has_prelu_param(); +} +const ::caffe::PReLUParameter& LayerParameter::prelu_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.prelu_param) + return prelu_param_ != NULL ? *prelu_param_ + : *::caffe::PReLUParameter::internal_default_instance(); +} +::caffe::PReLUParameter* LayerParameter::mutable_prelu_param() { + set_has_prelu_param(); + if (prelu_param_ == NULL) { + prelu_param_ = new ::caffe::PReLUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.prelu_param) + return prelu_param_; +} +::caffe::PReLUParameter* LayerParameter::release_prelu_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.prelu_param) + clear_has_prelu_param(); + ::caffe::PReLUParameter* temp = prelu_param_; + prelu_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_prelu_param(::caffe::PReLUParameter* prelu_param) { + delete prelu_param_; + prelu_param_ = prelu_param; + if (prelu_param) { + set_has_prelu_param(); + } else { + clear_has_prelu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.prelu_param) +} + +// optional .caffe.PriorBoxParameter prior_box_param = 150; +bool LayerParameter::has_prior_box_param() const { + return (_has_bits_[1] & 0x00008000u) != 0; +} +void LayerParameter::set_has_prior_box_param() { + _has_bits_[1] |= 0x00008000u; +} +void LayerParameter::clear_has_prior_box_param() { + _has_bits_[1] &= ~0x00008000u; +} +void LayerParameter::clear_prior_box_param() { + if (prior_box_param_ != NULL) prior_box_param_->::caffe::PriorBoxParameter::Clear(); + clear_has_prior_box_param(); +} +const ::caffe::PriorBoxParameter& LayerParameter::prior_box_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.prior_box_param) + return prior_box_param_ != NULL ? *prior_box_param_ + : *::caffe::PriorBoxParameter::internal_default_instance(); +} +::caffe::PriorBoxParameter* LayerParameter::mutable_prior_box_param() { + set_has_prior_box_param(); + if (prior_box_param_ == NULL) { + prior_box_param_ = new ::caffe::PriorBoxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.prior_box_param) + return prior_box_param_; +} +::caffe::PriorBoxParameter* LayerParameter::release_prior_box_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.prior_box_param) + clear_has_prior_box_param(); + ::caffe::PriorBoxParameter* temp = prior_box_param_; + prior_box_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_prior_box_param(::caffe::PriorBoxParameter* prior_box_param) { + delete prior_box_param_; + prior_box_param_ = prior_box_param; + if (prior_box_param) { + set_has_prior_box_param(); + } else { + clear_has_prior_box_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.prior_box_param) +} + +// optional .caffe.PythonParameter python_param = 130; +bool LayerParameter::has_python_param() const { + return (_has_bits_[1] & 0x00010000u) != 0; +} +void LayerParameter::set_has_python_param() { + _has_bits_[1] |= 0x00010000u; +} +void LayerParameter::clear_has_python_param() { + _has_bits_[1] &= ~0x00010000u; +} +void LayerParameter::clear_python_param() { + if (python_param_ != NULL) python_param_->::caffe::PythonParameter::Clear(); + clear_has_python_param(); +} +const ::caffe::PythonParameter& LayerParameter::python_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.python_param) + return python_param_ != NULL ? *python_param_ + : *::caffe::PythonParameter::internal_default_instance(); +} +::caffe::PythonParameter* LayerParameter::mutable_python_param() { + set_has_python_param(); + if (python_param_ == NULL) { + python_param_ = new ::caffe::PythonParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.python_param) + return python_param_; +} +::caffe::PythonParameter* LayerParameter::release_python_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.python_param) + clear_has_python_param(); + ::caffe::PythonParameter* temp = python_param_; + python_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_python_param(::caffe::PythonParameter* python_param) { + delete python_param_; + python_param_ = python_param; + if (python_param) { + set_has_python_param(); + } else { + clear_has_python_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.python_param) +} + +// optional .caffe.RecurrentParameter recurrent_param = 146; +bool LayerParameter::has_recurrent_param() const { + return (_has_bits_[1] & 0x00020000u) != 0; +} +void LayerParameter::set_has_recurrent_param() { + _has_bits_[1] |= 0x00020000u; +} +void LayerParameter::clear_has_recurrent_param() { + _has_bits_[1] &= ~0x00020000u; +} +void LayerParameter::clear_recurrent_param() { + if (recurrent_param_ != NULL) recurrent_param_->::caffe::RecurrentParameter::Clear(); + clear_has_recurrent_param(); +} +const ::caffe::RecurrentParameter& LayerParameter::recurrent_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.recurrent_param) + return recurrent_param_ != NULL ? *recurrent_param_ + : *::caffe::RecurrentParameter::internal_default_instance(); +} +::caffe::RecurrentParameter* LayerParameter::mutable_recurrent_param() { + set_has_recurrent_param(); + if (recurrent_param_ == NULL) { + recurrent_param_ = new ::caffe::RecurrentParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.recurrent_param) + return recurrent_param_; +} +::caffe::RecurrentParameter* LayerParameter::release_recurrent_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.recurrent_param) + clear_has_recurrent_param(); + ::caffe::RecurrentParameter* temp = recurrent_param_; + recurrent_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_recurrent_param(::caffe::RecurrentParameter* recurrent_param) { + delete recurrent_param_; + recurrent_param_ = recurrent_param; + if (recurrent_param) { + set_has_recurrent_param(); + } else { + clear_has_recurrent_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.recurrent_param) +} + +// optional .caffe.ReductionParameter reduction_param = 136; +bool LayerParameter::has_reduction_param() const { + return (_has_bits_[1] & 0x00040000u) != 0; +} +void LayerParameter::set_has_reduction_param() { + _has_bits_[1] |= 0x00040000u; +} +void LayerParameter::clear_has_reduction_param() { + _has_bits_[1] &= ~0x00040000u; +} +void LayerParameter::clear_reduction_param() { + if (reduction_param_ != NULL) reduction_param_->::caffe::ReductionParameter::Clear(); + clear_has_reduction_param(); +} +const ::caffe::ReductionParameter& LayerParameter::reduction_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.reduction_param) + return reduction_param_ != NULL ? *reduction_param_ + : *::caffe::ReductionParameter::internal_default_instance(); +} +::caffe::ReductionParameter* LayerParameter::mutable_reduction_param() { + set_has_reduction_param(); + if (reduction_param_ == NULL) { + reduction_param_ = new ::caffe::ReductionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.reduction_param) + return reduction_param_; +} +::caffe::ReductionParameter* LayerParameter::release_reduction_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.reduction_param) + clear_has_reduction_param(); + ::caffe::ReductionParameter* temp = reduction_param_; + reduction_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_reduction_param(::caffe::ReductionParameter* reduction_param) { + delete reduction_param_; + reduction_param_ = reduction_param; + if (reduction_param) { + set_has_reduction_param(); + } else { + clear_has_reduction_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.reduction_param) +} + +// optional .caffe.ReLUParameter relu_param = 123; +bool LayerParameter::has_relu_param() const { + return (_has_bits_[1] & 0x00080000u) != 0; +} +void LayerParameter::set_has_relu_param() { + _has_bits_[1] |= 0x00080000u; +} +void LayerParameter::clear_has_relu_param() { + _has_bits_[1] &= ~0x00080000u; +} +void LayerParameter::clear_relu_param() { + if (relu_param_ != NULL) relu_param_->::caffe::ReLUParameter::Clear(); + clear_has_relu_param(); +} +const ::caffe::ReLUParameter& LayerParameter::relu_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.relu_param) + return relu_param_ != NULL ? *relu_param_ + : *::caffe::ReLUParameter::internal_default_instance(); +} +::caffe::ReLUParameter* LayerParameter::mutable_relu_param() { + set_has_relu_param(); + if (relu_param_ == NULL) { + relu_param_ = new ::caffe::ReLUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.relu_param) + return relu_param_; +} +::caffe::ReLUParameter* LayerParameter::release_relu_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.relu_param) + clear_has_relu_param(); + ::caffe::ReLUParameter* temp = relu_param_; + relu_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_relu_param(::caffe::ReLUParameter* relu_param) { + delete relu_param_; + relu_param_ = relu_param; + if (relu_param) { + set_has_relu_param(); + } else { + clear_has_relu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.relu_param) +} + +// optional .caffe.ReshapeParameter reshape_param = 133; +bool LayerParameter::has_reshape_param() const { + return (_has_bits_[1] & 0x00100000u) != 0; +} +void LayerParameter::set_has_reshape_param() { + _has_bits_[1] |= 0x00100000u; +} +void LayerParameter::clear_has_reshape_param() { + _has_bits_[1] &= ~0x00100000u; +} +void LayerParameter::clear_reshape_param() { + if (reshape_param_ != NULL) reshape_param_->::caffe::ReshapeParameter::Clear(); + clear_has_reshape_param(); +} +const ::caffe::ReshapeParameter& LayerParameter::reshape_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.reshape_param) + return reshape_param_ != NULL ? *reshape_param_ + : *::caffe::ReshapeParameter::internal_default_instance(); +} +::caffe::ReshapeParameter* LayerParameter::mutable_reshape_param() { + set_has_reshape_param(); + if (reshape_param_ == NULL) { + reshape_param_ = new ::caffe::ReshapeParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.reshape_param) + return reshape_param_; +} +::caffe::ReshapeParameter* LayerParameter::release_reshape_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.reshape_param) + clear_has_reshape_param(); + ::caffe::ReshapeParameter* temp = reshape_param_; + reshape_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_reshape_param(::caffe::ReshapeParameter* reshape_param) { + delete reshape_param_; + reshape_param_ = reshape_param; + if (reshape_param) { + set_has_reshape_param(); + } else { + clear_has_reshape_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.reshape_param) +} + +// optional .caffe.ScaleParameter scale_param = 142; +bool LayerParameter::has_scale_param() const { + return (_has_bits_[1] & 0x00200000u) != 0; +} +void LayerParameter::set_has_scale_param() { + _has_bits_[1] |= 0x00200000u; +} +void LayerParameter::clear_has_scale_param() { + _has_bits_[1] &= ~0x00200000u; +} +void LayerParameter::clear_scale_param() { + if (scale_param_ != NULL) scale_param_->::caffe::ScaleParameter::Clear(); + clear_has_scale_param(); +} +const ::caffe::ScaleParameter& LayerParameter::scale_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.scale_param) + return scale_param_ != NULL ? *scale_param_ + : *::caffe::ScaleParameter::internal_default_instance(); +} +::caffe::ScaleParameter* LayerParameter::mutable_scale_param() { + set_has_scale_param(); + if (scale_param_ == NULL) { + scale_param_ = new ::caffe::ScaleParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.scale_param) + return scale_param_; +} +::caffe::ScaleParameter* LayerParameter::release_scale_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.scale_param) + clear_has_scale_param(); + ::caffe::ScaleParameter* temp = scale_param_; + scale_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_scale_param(::caffe::ScaleParameter* scale_param) { + delete scale_param_; + scale_param_ = scale_param; + if (scale_param) { + set_has_scale_param(); + } else { + clear_has_scale_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.scale_param) +} + +// optional .caffe.SigmoidParameter sigmoid_param = 124; +bool LayerParameter::has_sigmoid_param() const { + return (_has_bits_[1] & 0x00400000u) != 0; +} +void LayerParameter::set_has_sigmoid_param() { + _has_bits_[1] |= 0x00400000u; +} +void LayerParameter::clear_has_sigmoid_param() { + _has_bits_[1] &= ~0x00400000u; +} +void LayerParameter::clear_sigmoid_param() { + if (sigmoid_param_ != NULL) sigmoid_param_->::caffe::SigmoidParameter::Clear(); + clear_has_sigmoid_param(); +} +const ::caffe::SigmoidParameter& LayerParameter::sigmoid_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.sigmoid_param) + return sigmoid_param_ != NULL ? *sigmoid_param_ + : *::caffe::SigmoidParameter::internal_default_instance(); +} +::caffe::SigmoidParameter* LayerParameter::mutable_sigmoid_param() { + set_has_sigmoid_param(); + if (sigmoid_param_ == NULL) { + sigmoid_param_ = new ::caffe::SigmoidParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.sigmoid_param) + return sigmoid_param_; +} +::caffe::SigmoidParameter* LayerParameter::release_sigmoid_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.sigmoid_param) + clear_has_sigmoid_param(); + ::caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param) { + delete sigmoid_param_; + sigmoid_param_ = sigmoid_param; + if (sigmoid_param) { + set_has_sigmoid_param(); + } else { + clear_has_sigmoid_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.sigmoid_param) +} + +// optional .caffe.SoftmaxParameter softmax_param = 125; +bool LayerParameter::has_softmax_param() const { + return (_has_bits_[1] & 0x00800000u) != 0; +} +void LayerParameter::set_has_softmax_param() { + _has_bits_[1] |= 0x00800000u; +} +void LayerParameter::clear_has_softmax_param() { + _has_bits_[1] &= ~0x00800000u; +} +void LayerParameter::clear_softmax_param() { + if (softmax_param_ != NULL) softmax_param_->::caffe::SoftmaxParameter::Clear(); + clear_has_softmax_param(); +} +const ::caffe::SoftmaxParameter& LayerParameter::softmax_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.softmax_param) + return softmax_param_ != NULL ? *softmax_param_ + : *::caffe::SoftmaxParameter::internal_default_instance(); +} +::caffe::SoftmaxParameter* LayerParameter::mutable_softmax_param() { + set_has_softmax_param(); + if (softmax_param_ == NULL) { + softmax_param_ = new ::caffe::SoftmaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.softmax_param) + return softmax_param_; +} +::caffe::SoftmaxParameter* LayerParameter::release_softmax_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.softmax_param) + clear_has_softmax_param(); + ::caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param) { + delete softmax_param_; + softmax_param_ = softmax_param; + if (softmax_param) { + set_has_softmax_param(); + } else { + clear_has_softmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.softmax_param) +} + +// optional .caffe.SPPParameter spp_param = 132; +bool LayerParameter::has_spp_param() const { + return (_has_bits_[1] & 0x01000000u) != 0; +} +void LayerParameter::set_has_spp_param() { + _has_bits_[1] |= 0x01000000u; +} +void LayerParameter::clear_has_spp_param() { + _has_bits_[1] &= ~0x01000000u; +} +void LayerParameter::clear_spp_param() { + if (spp_param_ != NULL) spp_param_->::caffe::SPPParameter::Clear(); + clear_has_spp_param(); +} +const ::caffe::SPPParameter& LayerParameter::spp_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.spp_param) + return spp_param_ != NULL ? *spp_param_ + : *::caffe::SPPParameter::internal_default_instance(); +} +::caffe::SPPParameter* LayerParameter::mutable_spp_param() { + set_has_spp_param(); + if (spp_param_ == NULL) { + spp_param_ = new ::caffe::SPPParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.spp_param) + return spp_param_; +} +::caffe::SPPParameter* LayerParameter::release_spp_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.spp_param) + clear_has_spp_param(); + ::caffe::SPPParameter* temp = spp_param_; + spp_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_spp_param(::caffe::SPPParameter* spp_param) { + delete spp_param_; + spp_param_ = spp_param; + if (spp_param) { + set_has_spp_param(); + } else { + clear_has_spp_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.spp_param) +} + +// optional .caffe.SliceParameter slice_param = 126; +bool LayerParameter::has_slice_param() const { + return (_has_bits_[1] & 0x02000000u) != 0; +} +void LayerParameter::set_has_slice_param() { + _has_bits_[1] |= 0x02000000u; +} +void LayerParameter::clear_has_slice_param() { + _has_bits_[1] &= ~0x02000000u; +} +void LayerParameter::clear_slice_param() { + if (slice_param_ != NULL) slice_param_->::caffe::SliceParameter::Clear(); + clear_has_slice_param(); +} +const ::caffe::SliceParameter& LayerParameter::slice_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.slice_param) + return slice_param_ != NULL ? *slice_param_ + : *::caffe::SliceParameter::internal_default_instance(); +} +::caffe::SliceParameter* LayerParameter::mutable_slice_param() { + set_has_slice_param(); + if (slice_param_ == NULL) { + slice_param_ = new ::caffe::SliceParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.slice_param) + return slice_param_; +} +::caffe::SliceParameter* LayerParameter::release_slice_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.slice_param) + clear_has_slice_param(); + ::caffe::SliceParameter* temp = slice_param_; + slice_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_slice_param(::caffe::SliceParameter* slice_param) { + delete slice_param_; + slice_param_ = slice_param; + if (slice_param) { + set_has_slice_param(); + } else { + clear_has_slice_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.slice_param) +} + +// optional .caffe.TanHParameter tanh_param = 127; +bool LayerParameter::has_tanh_param() const { + return (_has_bits_[1] & 0x04000000u) != 0; +} +void LayerParameter::set_has_tanh_param() { + _has_bits_[1] |= 0x04000000u; +} +void LayerParameter::clear_has_tanh_param() { + _has_bits_[1] &= ~0x04000000u; +} +void LayerParameter::clear_tanh_param() { + if (tanh_param_ != NULL) tanh_param_->::caffe::TanHParameter::Clear(); + clear_has_tanh_param(); +} +const ::caffe::TanHParameter& LayerParameter::tanh_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.tanh_param) + return tanh_param_ != NULL ? *tanh_param_ + : *::caffe::TanHParameter::internal_default_instance(); +} +::caffe::TanHParameter* LayerParameter::mutable_tanh_param() { + set_has_tanh_param(); + if (tanh_param_ == NULL) { + tanh_param_ = new ::caffe::TanHParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.tanh_param) + return tanh_param_; +} +::caffe::TanHParameter* LayerParameter::release_tanh_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.tanh_param) + clear_has_tanh_param(); + ::caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_tanh_param(::caffe::TanHParameter* tanh_param) { + delete tanh_param_; + tanh_param_ = tanh_param; + if (tanh_param) { + set_has_tanh_param(); + } else { + clear_has_tanh_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.tanh_param) +} + +// optional .caffe.ThresholdParameter threshold_param = 128; +bool LayerParameter::has_threshold_param() const { + return (_has_bits_[1] & 0x08000000u) != 0; +} +void LayerParameter::set_has_threshold_param() { + _has_bits_[1] |= 0x08000000u; +} +void LayerParameter::clear_has_threshold_param() { + _has_bits_[1] &= ~0x08000000u; +} +void LayerParameter::clear_threshold_param() { + if (threshold_param_ != NULL) threshold_param_->::caffe::ThresholdParameter::Clear(); + clear_has_threshold_param(); +} +const ::caffe::ThresholdParameter& LayerParameter::threshold_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.threshold_param) + return threshold_param_ != NULL ? *threshold_param_ + : *::caffe::ThresholdParameter::internal_default_instance(); +} +::caffe::ThresholdParameter* LayerParameter::mutable_threshold_param() { + set_has_threshold_param(); + if (threshold_param_ == NULL) { + threshold_param_ = new ::caffe::ThresholdParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.threshold_param) + return threshold_param_; +} +::caffe::ThresholdParameter* LayerParameter::release_threshold_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.threshold_param) + clear_has_threshold_param(); + ::caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param) { + delete threshold_param_; + threshold_param_ = threshold_param; + if (threshold_param) { + set_has_threshold_param(); + } else { + clear_has_threshold_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.threshold_param) +} + +// optional .caffe.TileParameter tile_param = 138; +bool LayerParameter::has_tile_param() const { + return (_has_bits_[1] & 0x10000000u) != 0; +} +void LayerParameter::set_has_tile_param() { + _has_bits_[1] |= 0x10000000u; +} +void LayerParameter::clear_has_tile_param() { + _has_bits_[1] &= ~0x10000000u; +} +void LayerParameter::clear_tile_param() { + if (tile_param_ != NULL) tile_param_->::caffe::TileParameter::Clear(); + clear_has_tile_param(); +} +const ::caffe::TileParameter& LayerParameter::tile_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.tile_param) + return tile_param_ != NULL ? *tile_param_ + : *::caffe::TileParameter::internal_default_instance(); +} +::caffe::TileParameter* LayerParameter::mutable_tile_param() { + set_has_tile_param(); + if (tile_param_ == NULL) { + tile_param_ = new ::caffe::TileParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.tile_param) + return tile_param_; +} +::caffe::TileParameter* LayerParameter::release_tile_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.tile_param) + clear_has_tile_param(); + ::caffe::TileParameter* temp = tile_param_; + tile_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_tile_param(::caffe::TileParameter* tile_param) { + delete tile_param_; + tile_param_ = tile_param; + if (tile_param) { + set_has_tile_param(); + } else { + clear_has_tile_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.tile_param) +} + +// optional .caffe.WindowDataParameter window_data_param = 129; +bool LayerParameter::has_window_data_param() const { + return (_has_bits_[1] & 0x20000000u) != 0; +} +void LayerParameter::set_has_window_data_param() { + _has_bits_[1] |= 0x20000000u; +} +void LayerParameter::clear_has_window_data_param() { + _has_bits_[1] &= ~0x20000000u; +} +void LayerParameter::clear_window_data_param() { + if (window_data_param_ != NULL) window_data_param_->::caffe::WindowDataParameter::Clear(); + clear_has_window_data_param(); +} +const ::caffe::WindowDataParameter& LayerParameter::window_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.window_data_param) + return window_data_param_ != NULL ? *window_data_param_ + : *::caffe::WindowDataParameter::internal_default_instance(); +} +::caffe::WindowDataParameter* LayerParameter::mutable_window_data_param() { + set_has_window_data_param(); + if (window_data_param_ == NULL) { + window_data_param_ = new ::caffe::WindowDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.window_data_param) + return window_data_param_; +} +::caffe::WindowDataParameter* LayerParameter::release_window_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.window_data_param) + clear_has_window_data_param(); + ::caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = NULL; + return temp; +} +void LayerParameter::set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param) { + delete window_data_param_; + window_data_param_ = window_data_param; + if (window_data_param) { + set_has_window_data_param(); + } else { + clear_has_window_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.window_data_param) +} + +inline const LayerParameter* LayerParameter::internal_default_instance() { + return &LayerParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TransformationParameter::kScaleFieldNumber; +const int TransformationParameter::kMirrorFieldNumber; +const int TransformationParameter::kCropSizeFieldNumber; +const int TransformationParameter::kMeanFileFieldNumber; +const int TransformationParameter::kMeanValueFieldNumber; +const int TransformationParameter::kForceColorFieldNumber; +const int TransformationParameter::kForceGrayFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TransformationParameter::TransformationParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.TransformationParameter) +} + +void TransformationParameter::InitAsDefaultInstance() { +} + +TransformationParameter::TransformationParameter(const TransformationParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.TransformationParameter) +} + +void TransformationParameter::SharedCtor() { + _cached_size_ = 0; + mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&crop_size_, 0, reinterpret_cast(&force_gray_) - + reinterpret_cast(&crop_size_) + sizeof(force_gray_)); + scale_ = 1; +} + +TransformationParameter::~TransformationParameter() { + // @@protoc_insertion_point(destructor:caffe.TransformationParameter) + SharedDtor(); +} + +void TransformationParameter::SharedDtor() { + mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void TransformationParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TransformationParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TransformationParameter_descriptor_; +} + +const TransformationParameter& TransformationParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed TransformationParameter_default_instance_; + +TransformationParameter* TransformationParameter::New(::google::protobuf::Arena* arena) const { + TransformationParameter* n = new TransformationParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TransformationParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.TransformationParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(TransformationParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 111u) { + ZR_(crop_size_, force_gray_); + scale_ = 1; + if (has_mean_file()) { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + mean_value_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool TransformationParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.TransformationParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float scale = 1 [default = 1]; + case 1: { + if (tag == 13) { + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_mirror; + break; + } + + // optional bool mirror = 2 [default = false]; + case 2: { + if (tag == 16) { + parse_mirror: + set_has_mirror(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &mirror_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_crop_size; + break; + } + + // optional uint32 crop_size = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_crop_size: + set_has_crop_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &crop_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_mean_file; + break; + } + + // optional string mean_file = 4; + case 4: { + if (tag == 34) { + parse_mean_file: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_mean_file())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.TransformationParameter.mean_file"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_mean_value; + break; + } + + // repeated float mean_value = 5; + case 5: { + if (tag == 45) { + parse_mean_value: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 45, input, this->mutable_mean_value()))); + } else if (tag == 42) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_mean_value()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_mean_value; + if (input->ExpectTag(48)) goto parse_force_color; + break; + } + + // optional bool force_color = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_force_color: + set_has_force_color(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &force_color_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_force_gray; + break; + } + + // optional bool force_gray = 7 [default = false]; + case 7: { + if (tag == 56) { + parse_force_gray: + set_has_force_gray(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &force_gray_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.TransformationParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.TransformationParameter) + return false; +#undef DO_ +} + +void TransformationParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.TransformationParameter) + // optional float scale = 1 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->scale(), output); + } + + // optional bool mirror = 2 [default = false]; + if (has_mirror()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->mirror(), output); + } + + // optional uint32 crop_size = 3 [default = 0]; + if (has_crop_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->crop_size(), output); + } + + // optional string mean_file = 4; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.TransformationParameter.mean_file"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->mean_file(), output); + } + + // repeated float mean_value = 5; + for (int i = 0; i < this->mean_value_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 5, this->mean_value(i), output); + } + + // optional bool force_color = 6 [default = false]; + if (has_force_color()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->force_color(), output); + } + + // optional bool force_gray = 7 [default = false]; + if (has_force_gray()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->force_gray(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.TransformationParameter) +} + +::google::protobuf::uint8* TransformationParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.TransformationParameter) + // optional float scale = 1 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->scale(), target); + } + + // optional bool mirror = 2 [default = false]; + if (has_mirror()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->mirror(), target); + } + + // optional uint32 crop_size = 3 [default = 0]; + if (has_crop_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->crop_size(), target); + } + + // optional string mean_file = 4; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.TransformationParameter.mean_file"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->mean_file(), target); + } + + // repeated float mean_value = 5; + for (int i = 0; i < this->mean_value_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(5, this->mean_value(i), target); + } + + // optional bool force_color = 6 [default = false]; + if (has_force_color()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->force_color(), target); + } + + // optional bool force_gray = 7 [default = false]; + if (has_force_gray()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->force_gray(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.TransformationParameter) + return target; +} + +size_t TransformationParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.TransformationParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 111u) { + // optional float scale = 1 [default = 1]; + if (has_scale()) { + total_size += 1 + 4; + } + + // optional bool mirror = 2 [default = false]; + if (has_mirror()) { + total_size += 1 + 1; + } + + // optional uint32 crop_size = 3 [default = 0]; + if (has_crop_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->crop_size()); + } + + // optional string mean_file = 4; + if (has_mean_file()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->mean_file()); + } + + // optional bool force_color = 6 [default = false]; + if (has_force_color()) { + total_size += 1 + 1; + } + + // optional bool force_gray = 7 [default = false]; + if (has_force_gray()) { + total_size += 1 + 1; + } + + } + // repeated float mean_value = 5; + { + size_t data_size = 0; + unsigned int count = this->mean_value_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->mean_value_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TransformationParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.TransformationParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const TransformationParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.TransformationParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.TransformationParameter) + UnsafeMergeFrom(*source); + } +} + +void TransformationParameter::MergeFrom(const TransformationParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.TransformationParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void TransformationParameter::UnsafeMergeFrom(const TransformationParameter& from) { + GOOGLE_DCHECK(&from != this); + mean_value_.UnsafeMergeFrom(from.mean_value_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_mirror()) { + set_mirror(from.mirror()); + } + if (from.has_crop_size()) { + set_crop_size(from.crop_size()); + } + if (from.has_mean_file()) { + set_has_mean_file(); + mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_); + } + if (from.has_force_color()) { + set_force_color(from.force_color()); + } + if (from.has_force_gray()) { + set_force_gray(from.force_gray()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void TransformationParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.TransformationParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TransformationParameter::CopyFrom(const TransformationParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.TransformationParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool TransformationParameter::IsInitialized() const { + + return true; +} + +void TransformationParameter::Swap(TransformationParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void TransformationParameter::InternalSwap(TransformationParameter* other) { + std::swap(scale_, other->scale_); + std::swap(mirror_, other->mirror_); + std::swap(crop_size_, other->crop_size_); + mean_file_.Swap(&other->mean_file_); + mean_value_.UnsafeArenaSwap(&other->mean_value_); + std::swap(force_color_, other->force_color_); + std::swap(force_gray_, other->force_gray_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TransformationParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TransformationParameter_descriptor_; + metadata.reflection = TransformationParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// TransformationParameter + +// optional float scale = 1 [default = 1]; +bool TransformationParameter::has_scale() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void TransformationParameter::set_has_scale() { + _has_bits_[0] |= 0x00000001u; +} +void TransformationParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000001u; +} +void TransformationParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float TransformationParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.scale) + return scale_; +} +void TransformationParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.scale) +} + +// optional bool mirror = 2 [default = false]; +bool TransformationParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void TransformationParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000002u; +} +void TransformationParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000002u; +} +void TransformationParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +bool TransformationParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.mirror) + return mirror_; +} +void TransformationParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.mirror) +} + +// optional uint32 crop_size = 3 [default = 0]; +bool TransformationParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void TransformationParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000004u; +} +void TransformationParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000004u; +} +void TransformationParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +::google::protobuf::uint32 TransformationParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.crop_size) + return crop_size_; +} +void TransformationParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.crop_size) +} + +// optional string mean_file = 4; +bool TransformationParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void TransformationParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000008u; +} +void TransformationParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000008u; +} +void TransformationParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +const ::std::string& TransformationParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void TransformationParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.mean_file) +} +void TransformationParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.TransformationParameter.mean_file) +} +void TransformationParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.TransformationParameter.mean_file) +} +::std::string* TransformationParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* TransformationParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.TransformationParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void TransformationParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.mean_file) +} + +// repeated float mean_value = 5; +int TransformationParameter::mean_value_size() const { + return mean_value_.size(); +} +void TransformationParameter::clear_mean_value() { + mean_value_.Clear(); +} +float TransformationParameter::mean_value(int index) const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.mean_value) + return mean_value_.Get(index); +} +void TransformationParameter::set_mean_value(int index, float value) { + mean_value_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.mean_value) +} +void TransformationParameter::add_mean_value(float value) { + mean_value_.Add(value); + // @@protoc_insertion_point(field_add:caffe.TransformationParameter.mean_value) +} +const ::google::protobuf::RepeatedField< float >& +TransformationParameter::mean_value() const { + // @@protoc_insertion_point(field_list:caffe.TransformationParameter.mean_value) + return mean_value_; +} +::google::protobuf::RepeatedField< float >* +TransformationParameter::mutable_mean_value() { + // @@protoc_insertion_point(field_mutable_list:caffe.TransformationParameter.mean_value) + return &mean_value_; +} + +// optional bool force_color = 6 [default = false]; +bool TransformationParameter::has_force_color() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void TransformationParameter::set_has_force_color() { + _has_bits_[0] |= 0x00000020u; +} +void TransformationParameter::clear_has_force_color() { + _has_bits_[0] &= ~0x00000020u; +} +void TransformationParameter::clear_force_color() { + force_color_ = false; + clear_has_force_color(); +} +bool TransformationParameter::force_color() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.force_color) + return force_color_; +} +void TransformationParameter::set_force_color(bool value) { + set_has_force_color(); + force_color_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.force_color) +} + +// optional bool force_gray = 7 [default = false]; +bool TransformationParameter::has_force_gray() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void TransformationParameter::set_has_force_gray() { + _has_bits_[0] |= 0x00000040u; +} +void TransformationParameter::clear_has_force_gray() { + _has_bits_[0] &= ~0x00000040u; +} +void TransformationParameter::clear_force_gray() { + force_gray_ = false; + clear_has_force_gray(); +} +bool TransformationParameter::force_gray() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.force_gray) + return force_gray_; +} +void TransformationParameter::set_force_gray(bool value) { + set_has_force_gray(); + force_gray_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.force_gray) +} + +inline const TransformationParameter* TransformationParameter::internal_default_instance() { + return &TransformationParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* LossParameter_NormalizationMode_descriptor() { + protobuf_AssignDescriptorsOnce(); + return LossParameter_NormalizationMode_descriptor_; +} +bool LossParameter_NormalizationMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const LossParameter_NormalizationMode LossParameter::FULL; +const LossParameter_NormalizationMode LossParameter::VALID; +const LossParameter_NormalizationMode LossParameter::BATCH_SIZE; +const LossParameter_NormalizationMode LossParameter::NONE; +const LossParameter_NormalizationMode LossParameter::NormalizationMode_MIN; +const LossParameter_NormalizationMode LossParameter::NormalizationMode_MAX; +const int LossParameter::NormalizationMode_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int LossParameter::kIgnoreLabelFieldNumber; +const int LossParameter::kNormalizationFieldNumber; +const int LossParameter::kNormalizeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +LossParameter::LossParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.LossParameter) +} + +void LossParameter::InitAsDefaultInstance() { +} + +LossParameter::LossParameter(const LossParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.LossParameter) +} + +void LossParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&ignore_label_, 0, reinterpret_cast(&normalize_) - + reinterpret_cast(&ignore_label_) + sizeof(normalize_)); + normalization_ = 1; +} + +LossParameter::~LossParameter() { + // @@protoc_insertion_point(destructor:caffe.LossParameter) + SharedDtor(); +} + +void LossParameter::SharedDtor() { +} + +void LossParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LossParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LossParameter_descriptor_; +} + +const LossParameter& LossParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed LossParameter_default_instance_; + +LossParameter* LossParameter::New(::google::protobuf::Arena* arena) const { + LossParameter* n = new LossParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void LossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.LossParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(LossParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 7u) { + ZR_(ignore_label_, normalize_); + normalization_ = 1; + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool LossParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.LossParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 ignore_label = 1; + case 1: { + if (tag == 8) { + set_has_ignore_label(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &ignore_label_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_normalize; + break; + } + + // optional bool normalize = 2; + case 2: { + if (tag == 16) { + parse_normalize: + set_has_normalize(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &normalize_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_normalization; + break; + } + + // optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + case 3: { + if (tag == 24) { + parse_normalization: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::LossParameter_NormalizationMode_IsValid(value)) { + set_normalization(static_cast< ::caffe::LossParameter_NormalizationMode >(value)); + } else { + mutable_unknown_fields()->AddVarint(3, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.LossParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.LossParameter) + return false; +#undef DO_ +} + +void LossParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.LossParameter) + // optional int32 ignore_label = 1; + if (has_ignore_label()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->ignore_label(), output); + } + + // optional bool normalize = 2; + if (has_normalize()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->normalize(), output); + } + + // optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + if (has_normalization()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 3, this->normalization(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.LossParameter) +} + +::google::protobuf::uint8* LossParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.LossParameter) + // optional int32 ignore_label = 1; + if (has_ignore_label()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->ignore_label(), target); + } + + // optional bool normalize = 2; + if (has_normalize()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->normalize(), target); + } + + // optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + if (has_normalization()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 3, this->normalization(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.LossParameter) + return target; +} + +size_t LossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.LossParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional int32 ignore_label = 1; + if (has_ignore_label()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->ignore_label()); + } + + // optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + if (has_normalization()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->normalization()); + } + + // optional bool normalize = 2; + if (has_normalize()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void LossParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.LossParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const LossParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.LossParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.LossParameter) + UnsafeMergeFrom(*source); + } +} + +void LossParameter::MergeFrom(const LossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.LossParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void LossParameter::UnsafeMergeFrom(const LossParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_ignore_label()) { + set_ignore_label(from.ignore_label()); + } + if (from.has_normalization()) { + set_normalization(from.normalization()); + } + if (from.has_normalize()) { + set_normalize(from.normalize()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void LossParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.LossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LossParameter::CopyFrom(const LossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.LossParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool LossParameter::IsInitialized() const { + + return true; +} + +void LossParameter::Swap(LossParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void LossParameter::InternalSwap(LossParameter* other) { + std::swap(ignore_label_, other->ignore_label_); + std::swap(normalization_, other->normalization_); + std::swap(normalize_, other->normalize_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata LossParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LossParameter_descriptor_; + metadata.reflection = LossParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// LossParameter + +// optional int32 ignore_label = 1; +bool LossParameter::has_ignore_label() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void LossParameter::set_has_ignore_label() { + _has_bits_[0] |= 0x00000001u; +} +void LossParameter::clear_has_ignore_label() { + _has_bits_[0] &= ~0x00000001u; +} +void LossParameter::clear_ignore_label() { + ignore_label_ = 0; + clear_has_ignore_label(); +} +::google::protobuf::int32 LossParameter::ignore_label() const { + // @@protoc_insertion_point(field_get:caffe.LossParameter.ignore_label) + return ignore_label_; +} +void LossParameter::set_ignore_label(::google::protobuf::int32 value) { + set_has_ignore_label(); + ignore_label_ = value; + // @@protoc_insertion_point(field_set:caffe.LossParameter.ignore_label) +} + +// optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; +bool LossParameter::has_normalization() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void LossParameter::set_has_normalization() { + _has_bits_[0] |= 0x00000002u; +} +void LossParameter::clear_has_normalization() { + _has_bits_[0] &= ~0x00000002u; +} +void LossParameter::clear_normalization() { + normalization_ = 1; + clear_has_normalization(); +} +::caffe::LossParameter_NormalizationMode LossParameter::normalization() const { + // @@protoc_insertion_point(field_get:caffe.LossParameter.normalization) + return static_cast< ::caffe::LossParameter_NormalizationMode >(normalization_); +} +void LossParameter::set_normalization(::caffe::LossParameter_NormalizationMode value) { + assert(::caffe::LossParameter_NormalizationMode_IsValid(value)); + set_has_normalization(); + normalization_ = value; + // @@protoc_insertion_point(field_set:caffe.LossParameter.normalization) +} + +// optional bool normalize = 2; +bool LossParameter::has_normalize() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void LossParameter::set_has_normalize() { + _has_bits_[0] |= 0x00000004u; +} +void LossParameter::clear_has_normalize() { + _has_bits_[0] &= ~0x00000004u; +} +void LossParameter::clear_normalize() { + normalize_ = false; + clear_has_normalize(); +} +bool LossParameter::normalize() const { + // @@protoc_insertion_point(field_get:caffe.LossParameter.normalize) + return normalize_; +} +void LossParameter::set_normalize(bool value) { + set_has_normalize(); + normalize_ = value; + // @@protoc_insertion_point(field_set:caffe.LossParameter.normalize) +} + +inline const LossParameter* LossParameter::internal_default_instance() { + return &LossParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int AccuracyParameter::kTopKFieldNumber; +const int AccuracyParameter::kAxisFieldNumber; +const int AccuracyParameter::kIgnoreLabelFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +AccuracyParameter::AccuracyParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.AccuracyParameter) +} + +void AccuracyParameter::InitAsDefaultInstance() { +} + +AccuracyParameter::AccuracyParameter(const AccuracyParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.AccuracyParameter) +} + +void AccuracyParameter::SharedCtor() { + _cached_size_ = 0; + ignore_label_ = 0; + top_k_ = 1u; + axis_ = 1; +} + +AccuracyParameter::~AccuracyParameter() { + // @@protoc_insertion_point(destructor:caffe.AccuracyParameter) + SharedDtor(); +} + +void AccuracyParameter::SharedDtor() { +} + +void AccuracyParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccuracyParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccuracyParameter_descriptor_; +} + +const AccuracyParameter& AccuracyParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed AccuracyParameter_default_instance_; + +AccuracyParameter* AccuracyParameter::New(::google::protobuf::Arena* arena) const { + AccuracyParameter* n = new AccuracyParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void AccuracyParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.AccuracyParameter) + if (_has_bits_[0 / 32] & 7u) { + top_k_ = 1u; + axis_ = 1; + ignore_label_ = 0; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool AccuracyParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.AccuracyParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 top_k = 1 [default = 1]; + case 1: { + if (tag == 8) { + set_has_top_k(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &top_k_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_axis; + break; + } + + // optional int32 axis = 2 [default = 1]; + case 2: { + if (tag == 16) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_ignore_label; + break; + } + + // optional int32 ignore_label = 3; + case 3: { + if (tag == 24) { + parse_ignore_label: + set_has_ignore_label(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &ignore_label_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.AccuracyParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.AccuracyParameter) + return false; +#undef DO_ +} + +void AccuracyParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.AccuracyParameter) + // optional uint32 top_k = 1 [default = 1]; + if (has_top_k()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->top_k(), output); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output); + } + + // optional int32 ignore_label = 3; + if (has_ignore_label()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->ignore_label(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.AccuracyParameter) +} + +::google::protobuf::uint8* AccuracyParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.AccuracyParameter) + // optional uint32 top_k = 1 [default = 1]; + if (has_top_k()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->top_k(), target); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target); + } + + // optional int32 ignore_label = 3; + if (has_ignore_label()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->ignore_label(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.AccuracyParameter) + return target; +} + +size_t AccuracyParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.AccuracyParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional uint32 top_k = 1 [default = 1]; + if (has_top_k()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->top_k()); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional int32 ignore_label = 3; + if (has_ignore_label()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->ignore_label()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AccuracyParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.AccuracyParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const AccuracyParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.AccuracyParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.AccuracyParameter) + UnsafeMergeFrom(*source); + } +} + +void AccuracyParameter::MergeFrom(const AccuracyParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.AccuracyParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void AccuracyParameter::UnsafeMergeFrom(const AccuracyParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_top_k()) { + set_top_k(from.top_k()); + } + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_ignore_label()) { + set_ignore_label(from.ignore_label()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void AccuracyParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.AccuracyParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccuracyParameter::CopyFrom(const AccuracyParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.AccuracyParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool AccuracyParameter::IsInitialized() const { + + return true; +} + +void AccuracyParameter::Swap(AccuracyParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void AccuracyParameter::InternalSwap(AccuracyParameter* other) { + std::swap(top_k_, other->top_k_); + std::swap(axis_, other->axis_); + std::swap(ignore_label_, other->ignore_label_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata AccuracyParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccuracyParameter_descriptor_; + metadata.reflection = AccuracyParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// AccuracyParameter + +// optional uint32 top_k = 1 [default = 1]; +bool AccuracyParameter::has_top_k() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void AccuracyParameter::set_has_top_k() { + _has_bits_[0] |= 0x00000001u; +} +void AccuracyParameter::clear_has_top_k() { + _has_bits_[0] &= ~0x00000001u; +} +void AccuracyParameter::clear_top_k() { + top_k_ = 1u; + clear_has_top_k(); +} +::google::protobuf::uint32 AccuracyParameter::top_k() const { + // @@protoc_insertion_point(field_get:caffe.AccuracyParameter.top_k) + return top_k_; +} +void AccuracyParameter::set_top_k(::google::protobuf::uint32 value) { + set_has_top_k(); + top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.AccuracyParameter.top_k) +} + +// optional int32 axis = 2 [default = 1]; +bool AccuracyParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void AccuracyParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +void AccuracyParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +void AccuracyParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 AccuracyParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.AccuracyParameter.axis) + return axis_; +} +void AccuracyParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.AccuracyParameter.axis) +} + +// optional int32 ignore_label = 3; +bool AccuracyParameter::has_ignore_label() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void AccuracyParameter::set_has_ignore_label() { + _has_bits_[0] |= 0x00000004u; +} +void AccuracyParameter::clear_has_ignore_label() { + _has_bits_[0] &= ~0x00000004u; +} +void AccuracyParameter::clear_ignore_label() { + ignore_label_ = 0; + clear_has_ignore_label(); +} +::google::protobuf::int32 AccuracyParameter::ignore_label() const { + // @@protoc_insertion_point(field_get:caffe.AccuracyParameter.ignore_label) + return ignore_label_; +} +void AccuracyParameter::set_ignore_label(::google::protobuf::int32 value) { + set_has_ignore_label(); + ignore_label_ = value; + // @@protoc_insertion_point(field_set:caffe.AccuracyParameter.ignore_label) +} + +inline const AccuracyParameter* AccuracyParameter::internal_default_instance() { + return &AccuracyParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ArgMaxParameter::kOutMaxValFieldNumber; +const int ArgMaxParameter::kTopKFieldNumber; +const int ArgMaxParameter::kAxisFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ArgMaxParameter::ArgMaxParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ArgMaxParameter) +} + +void ArgMaxParameter::InitAsDefaultInstance() { +} + +ArgMaxParameter::ArgMaxParameter(const ArgMaxParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ArgMaxParameter) +} + +void ArgMaxParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&out_max_val_, 0, reinterpret_cast(&axis_) - + reinterpret_cast(&out_max_val_) + sizeof(axis_)); + top_k_ = 1u; +} + +ArgMaxParameter::~ArgMaxParameter() { + // @@protoc_insertion_point(destructor:caffe.ArgMaxParameter) + SharedDtor(); +} + +void ArgMaxParameter::SharedDtor() { +} + +void ArgMaxParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ArgMaxParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ArgMaxParameter_descriptor_; +} + +const ArgMaxParameter& ArgMaxParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ArgMaxParameter_default_instance_; + +ArgMaxParameter* ArgMaxParameter::New(::google::protobuf::Arena* arena) const { + ArgMaxParameter* n = new ArgMaxParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ArgMaxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ArgMaxParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(ArgMaxParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 7u) { + ZR_(out_max_val_, axis_); + top_k_ = 1u; + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ArgMaxParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ArgMaxParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bool out_max_val = 1 [default = false]; + case 1: { + if (tag == 8) { + set_has_out_max_val(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &out_max_val_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_top_k; + break; + } + + // optional uint32 top_k = 2 [default = 1]; + case 2: { + if (tag == 16) { + parse_top_k: + set_has_top_k(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &top_k_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_axis; + break; + } + + // optional int32 axis = 3; + case 3: { + if (tag == 24) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ArgMaxParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ArgMaxParameter) + return false; +#undef DO_ +} + +void ArgMaxParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ArgMaxParameter) + // optional bool out_max_val = 1 [default = false]; + if (has_out_max_val()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->out_max_val(), output); + } + + // optional uint32 top_k = 2 [default = 1]; + if (has_top_k()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->top_k(), output); + } + + // optional int32 axis = 3; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->axis(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ArgMaxParameter) +} + +::google::protobuf::uint8* ArgMaxParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ArgMaxParameter) + // optional bool out_max_val = 1 [default = false]; + if (has_out_max_val()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->out_max_val(), target); + } + + // optional uint32 top_k = 2 [default = 1]; + if (has_top_k()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->top_k(), target); + } + + // optional int32 axis = 3; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->axis(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ArgMaxParameter) + return target; +} + +size_t ArgMaxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ArgMaxParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional bool out_max_val = 1 [default = false]; + if (has_out_max_val()) { + total_size += 1 + 1; + } + + // optional uint32 top_k = 2 [default = 1]; + if (has_top_k()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->top_k()); + } + + // optional int32 axis = 3; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ArgMaxParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ArgMaxParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ArgMaxParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ArgMaxParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ArgMaxParameter) + UnsafeMergeFrom(*source); + } +} + +void ArgMaxParameter::MergeFrom(const ArgMaxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ArgMaxParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ArgMaxParameter::UnsafeMergeFrom(const ArgMaxParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_out_max_val()) { + set_out_max_val(from.out_max_val()); + } + if (from.has_top_k()) { + set_top_k(from.top_k()); + } + if (from.has_axis()) { + set_axis(from.axis()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ArgMaxParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ArgMaxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ArgMaxParameter::CopyFrom(const ArgMaxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ArgMaxParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ArgMaxParameter::IsInitialized() const { + + return true; +} + +void ArgMaxParameter::Swap(ArgMaxParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ArgMaxParameter::InternalSwap(ArgMaxParameter* other) { + std::swap(out_max_val_, other->out_max_val_); + std::swap(top_k_, other->top_k_); + std::swap(axis_, other->axis_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ArgMaxParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ArgMaxParameter_descriptor_; + metadata.reflection = ArgMaxParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ArgMaxParameter + +// optional bool out_max_val = 1 [default = false]; +bool ArgMaxParameter::has_out_max_val() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ArgMaxParameter::set_has_out_max_val() { + _has_bits_[0] |= 0x00000001u; +} +void ArgMaxParameter::clear_has_out_max_val() { + _has_bits_[0] &= ~0x00000001u; +} +void ArgMaxParameter::clear_out_max_val() { + out_max_val_ = false; + clear_has_out_max_val(); +} +bool ArgMaxParameter::out_max_val() const { + // @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.out_max_val) + return out_max_val_; +} +void ArgMaxParameter::set_out_max_val(bool value) { + set_has_out_max_val(); + out_max_val_ = value; + // @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.out_max_val) +} + +// optional uint32 top_k = 2 [default = 1]; +bool ArgMaxParameter::has_top_k() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ArgMaxParameter::set_has_top_k() { + _has_bits_[0] |= 0x00000002u; +} +void ArgMaxParameter::clear_has_top_k() { + _has_bits_[0] &= ~0x00000002u; +} +void ArgMaxParameter::clear_top_k() { + top_k_ = 1u; + clear_has_top_k(); +} +::google::protobuf::uint32 ArgMaxParameter::top_k() const { + // @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.top_k) + return top_k_; +} +void ArgMaxParameter::set_top_k(::google::protobuf::uint32 value) { + set_has_top_k(); + top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.top_k) +} + +// optional int32 axis = 3; +bool ArgMaxParameter::has_axis() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void ArgMaxParameter::set_has_axis() { + _has_bits_[0] |= 0x00000004u; +} +void ArgMaxParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000004u; +} +void ArgMaxParameter::clear_axis() { + axis_ = 0; + clear_has_axis(); +} +::google::protobuf::int32 ArgMaxParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.axis) + return axis_; +} +void ArgMaxParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.axis) +} + +inline const ArgMaxParameter* ArgMaxParameter::internal_default_instance() { + return &ArgMaxParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ConcatParameter::kAxisFieldNumber; +const int ConcatParameter::kConcatDimFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ConcatParameter::ConcatParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ConcatParameter) +} + +void ConcatParameter::InitAsDefaultInstance() { +} + +ConcatParameter::ConcatParameter(const ConcatParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ConcatParameter) +} + +void ConcatParameter::SharedCtor() { + _cached_size_ = 0; + axis_ = 1; + concat_dim_ = 1u; +} + +ConcatParameter::~ConcatParameter() { + // @@protoc_insertion_point(destructor:caffe.ConcatParameter) + SharedDtor(); +} + +void ConcatParameter::SharedDtor() { +} + +void ConcatParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ConcatParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConcatParameter_descriptor_; +} + +const ConcatParameter& ConcatParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ConcatParameter_default_instance_; + +ConcatParameter* ConcatParameter::New(::google::protobuf::Arena* arena) const { + ConcatParameter* n = new ConcatParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ConcatParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ConcatParameter) + if (_has_bits_[0 / 32] & 3u) { + axis_ = 1; + concat_dim_ = 1u; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ConcatParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ConcatParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 concat_dim = 1 [default = 1]; + case 1: { + if (tag == 8) { + set_has_concat_dim(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &concat_dim_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_axis; + break; + } + + // optional int32 axis = 2 [default = 1]; + case 2: { + if (tag == 16) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ConcatParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ConcatParameter) + return false; +#undef DO_ +} + +void ConcatParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ConcatParameter) + // optional uint32 concat_dim = 1 [default = 1]; + if (has_concat_dim()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->concat_dim(), output); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ConcatParameter) +} + +::google::protobuf::uint8* ConcatParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ConcatParameter) + // optional uint32 concat_dim = 1 [default = 1]; + if (has_concat_dim()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->concat_dim(), target); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ConcatParameter) + return target; +} + +size_t ConcatParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ConcatParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional uint32 concat_dim = 1 [default = 1]; + if (has_concat_dim()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->concat_dim()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ConcatParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ConcatParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ConcatParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ConcatParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ConcatParameter) + UnsafeMergeFrom(*source); + } +} + +void ConcatParameter::MergeFrom(const ConcatParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ConcatParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ConcatParameter::UnsafeMergeFrom(const ConcatParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_concat_dim()) { + set_concat_dim(from.concat_dim()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ConcatParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ConcatParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ConcatParameter::CopyFrom(const ConcatParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ConcatParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ConcatParameter::IsInitialized() const { + + return true; +} + +void ConcatParameter::Swap(ConcatParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ConcatParameter::InternalSwap(ConcatParameter* other) { + std::swap(axis_, other->axis_); + std::swap(concat_dim_, other->concat_dim_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ConcatParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ConcatParameter_descriptor_; + metadata.reflection = ConcatParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ConcatParameter + +// optional int32 axis = 2 [default = 1]; +bool ConcatParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ConcatParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +void ConcatParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +void ConcatParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 ConcatParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ConcatParameter.axis) + return axis_; +} +void ConcatParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ConcatParameter.axis) +} + +// optional uint32 concat_dim = 1 [default = 1]; +bool ConcatParameter::has_concat_dim() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ConcatParameter::set_has_concat_dim() { + _has_bits_[0] |= 0x00000002u; +} +void ConcatParameter::clear_has_concat_dim() { + _has_bits_[0] &= ~0x00000002u; +} +void ConcatParameter::clear_concat_dim() { + concat_dim_ = 1u; + clear_has_concat_dim(); +} +::google::protobuf::uint32 ConcatParameter::concat_dim() const { + // @@protoc_insertion_point(field_get:caffe.ConcatParameter.concat_dim) + return concat_dim_; +} +void ConcatParameter::set_concat_dim(::google::protobuf::uint32 value) { + set_has_concat_dim(); + concat_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.ConcatParameter.concat_dim) +} + +inline const ConcatParameter* ConcatParameter::internal_default_instance() { + return &ConcatParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int BatchNormParameter::kUseGlobalStatsFieldNumber; +const int BatchNormParameter::kMovingAverageFractionFieldNumber; +const int BatchNormParameter::kEpsFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +BatchNormParameter::BatchNormParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.BatchNormParameter) +} + +void BatchNormParameter::InitAsDefaultInstance() { +} + +BatchNormParameter::BatchNormParameter(const BatchNormParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.BatchNormParameter) +} + +void BatchNormParameter::SharedCtor() { + _cached_size_ = 0; + use_global_stats_ = false; + moving_average_fraction_ = 0.999f; + eps_ = 1e-05f; +} + +BatchNormParameter::~BatchNormParameter() { + // @@protoc_insertion_point(destructor:caffe.BatchNormParameter) + SharedDtor(); +} + +void BatchNormParameter::SharedDtor() { +} + +void BatchNormParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BatchNormParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BatchNormParameter_descriptor_; +} + +const BatchNormParameter& BatchNormParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed BatchNormParameter_default_instance_; + +BatchNormParameter* BatchNormParameter::New(::google::protobuf::Arena* arena) const { + BatchNormParameter* n = new BatchNormParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void BatchNormParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.BatchNormParameter) + if (_has_bits_[0 / 32] & 7u) { + use_global_stats_ = false; + moving_average_fraction_ = 0.999f; + eps_ = 1e-05f; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool BatchNormParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.BatchNormParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bool use_global_stats = 1; + case 1: { + if (tag == 8) { + set_has_use_global_stats(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &use_global_stats_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_moving_average_fraction; + break; + } + + // optional float moving_average_fraction = 2 [default = 0.999]; + case 2: { + if (tag == 21) { + parse_moving_average_fraction: + set_has_moving_average_fraction(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &moving_average_fraction_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_eps; + break; + } + + // optional float eps = 3 [default = 1e-05]; + case 3: { + if (tag == 29) { + parse_eps: + set_has_eps(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &eps_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.BatchNormParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.BatchNormParameter) + return false; +#undef DO_ +} + +void BatchNormParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.BatchNormParameter) + // optional bool use_global_stats = 1; + if (has_use_global_stats()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->use_global_stats(), output); + } + + // optional float moving_average_fraction = 2 [default = 0.999]; + if (has_moving_average_fraction()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->moving_average_fraction(), output); + } + + // optional float eps = 3 [default = 1e-05]; + if (has_eps()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->eps(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.BatchNormParameter) +} + +::google::protobuf::uint8* BatchNormParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.BatchNormParameter) + // optional bool use_global_stats = 1; + if (has_use_global_stats()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->use_global_stats(), target); + } + + // optional float moving_average_fraction = 2 [default = 0.999]; + if (has_moving_average_fraction()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->moving_average_fraction(), target); + } + + // optional float eps = 3 [default = 1e-05]; + if (has_eps()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->eps(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.BatchNormParameter) + return target; +} + +size_t BatchNormParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.BatchNormParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional bool use_global_stats = 1; + if (has_use_global_stats()) { + total_size += 1 + 1; + } + + // optional float moving_average_fraction = 2 [default = 0.999]; + if (has_moving_average_fraction()) { + total_size += 1 + 4; + } + + // optional float eps = 3 [default = 1e-05]; + if (has_eps()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BatchNormParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.BatchNormParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const BatchNormParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.BatchNormParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.BatchNormParameter) + UnsafeMergeFrom(*source); + } +} + +void BatchNormParameter::MergeFrom(const BatchNormParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.BatchNormParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void BatchNormParameter::UnsafeMergeFrom(const BatchNormParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_use_global_stats()) { + set_use_global_stats(from.use_global_stats()); + } + if (from.has_moving_average_fraction()) { + set_moving_average_fraction(from.moving_average_fraction()); + } + if (from.has_eps()) { + set_eps(from.eps()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void BatchNormParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.BatchNormParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BatchNormParameter::CopyFrom(const BatchNormParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.BatchNormParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool BatchNormParameter::IsInitialized() const { + + return true; +} + +void BatchNormParameter::Swap(BatchNormParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void BatchNormParameter::InternalSwap(BatchNormParameter* other) { + std::swap(use_global_stats_, other->use_global_stats_); + std::swap(moving_average_fraction_, other->moving_average_fraction_); + std::swap(eps_, other->eps_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata BatchNormParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BatchNormParameter_descriptor_; + metadata.reflection = BatchNormParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// BatchNormParameter + +// optional bool use_global_stats = 1; +bool BatchNormParameter::has_use_global_stats() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void BatchNormParameter::set_has_use_global_stats() { + _has_bits_[0] |= 0x00000001u; +} +void BatchNormParameter::clear_has_use_global_stats() { + _has_bits_[0] &= ~0x00000001u; +} +void BatchNormParameter::clear_use_global_stats() { + use_global_stats_ = false; + clear_has_use_global_stats(); +} +bool BatchNormParameter::use_global_stats() const { + // @@protoc_insertion_point(field_get:caffe.BatchNormParameter.use_global_stats) + return use_global_stats_; +} +void BatchNormParameter::set_use_global_stats(bool value) { + set_has_use_global_stats(); + use_global_stats_ = value; + // @@protoc_insertion_point(field_set:caffe.BatchNormParameter.use_global_stats) +} + +// optional float moving_average_fraction = 2 [default = 0.999]; +bool BatchNormParameter::has_moving_average_fraction() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void BatchNormParameter::set_has_moving_average_fraction() { + _has_bits_[0] |= 0x00000002u; +} +void BatchNormParameter::clear_has_moving_average_fraction() { + _has_bits_[0] &= ~0x00000002u; +} +void BatchNormParameter::clear_moving_average_fraction() { + moving_average_fraction_ = 0.999f; + clear_has_moving_average_fraction(); +} +float BatchNormParameter::moving_average_fraction() const { + // @@protoc_insertion_point(field_get:caffe.BatchNormParameter.moving_average_fraction) + return moving_average_fraction_; +} +void BatchNormParameter::set_moving_average_fraction(float value) { + set_has_moving_average_fraction(); + moving_average_fraction_ = value; + // @@protoc_insertion_point(field_set:caffe.BatchNormParameter.moving_average_fraction) +} + +// optional float eps = 3 [default = 1e-05]; +bool BatchNormParameter::has_eps() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void BatchNormParameter::set_has_eps() { + _has_bits_[0] |= 0x00000004u; +} +void BatchNormParameter::clear_has_eps() { + _has_bits_[0] &= ~0x00000004u; +} +void BatchNormParameter::clear_eps() { + eps_ = 1e-05f; + clear_has_eps(); +} +float BatchNormParameter::eps() const { + // @@protoc_insertion_point(field_get:caffe.BatchNormParameter.eps) + return eps_; +} +void BatchNormParameter::set_eps(float value) { + set_has_eps(); + eps_ = value; + // @@protoc_insertion_point(field_set:caffe.BatchNormParameter.eps) +} + +inline const BatchNormParameter* BatchNormParameter::internal_default_instance() { + return &BatchNormParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int BiasParameter::kAxisFieldNumber; +const int BiasParameter::kNumAxesFieldNumber; +const int BiasParameter::kFillerFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +BiasParameter::BiasParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.BiasParameter) +} + +void BiasParameter::InitAsDefaultInstance() { + filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +BiasParameter::BiasParameter(const BiasParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.BiasParameter) +} + +void BiasParameter::SharedCtor() { + _cached_size_ = 0; + filler_ = NULL; + axis_ = 1; + num_axes_ = 1; +} + +BiasParameter::~BiasParameter() { + // @@protoc_insertion_point(destructor:caffe.BiasParameter) + SharedDtor(); +} + +void BiasParameter::SharedDtor() { + if (this != &BiasParameter_default_instance_.get()) { + delete filler_; + } +} + +void BiasParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BiasParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BiasParameter_descriptor_; +} + +const BiasParameter& BiasParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed BiasParameter_default_instance_; + +BiasParameter* BiasParameter::New(::google::protobuf::Arena* arena) const { + BiasParameter* n = new BiasParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void BiasParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.BiasParameter) + if (_has_bits_[0 / 32] & 7u) { + axis_ = 1; + num_axes_ = 1; + if (has_filler()) { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + } + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool BiasParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.BiasParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 axis = 1 [default = 1]; + case 1: { + if (tag == 8) { + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_num_axes; + break; + } + + // optional int32 num_axes = 2 [default = 1]; + case 2: { + if (tag == 16) { + parse_num_axes: + set_has_num_axes(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &num_axes_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_filler; + break; + } + + // optional .caffe.FillerParameter filler = 3; + case 3: { + if (tag == 26) { + parse_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.BiasParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.BiasParameter) + return false; +#undef DO_ +} + +void BiasParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.BiasParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output); + } + + // optional int32 num_axes = 2 [default = 1]; + if (has_num_axes()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_axes(), output); + } + + // optional .caffe.FillerParameter filler = 3; + if (has_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, *this->filler_, output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.BiasParameter) +} + +::google::protobuf::uint8* BiasParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.BiasParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target); + } + + // optional int32 num_axes = 2 [default = 1]; + if (has_num_axes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_axes(), target); + } + + // optional .caffe.FillerParameter filler = 3; + if (has_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 3, *this->filler_, false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.BiasParameter) + return target; +} + +size_t BiasParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.BiasParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional int32 num_axes = 2 [default = 1]; + if (has_num_axes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->num_axes()); + } + + // optional .caffe.FillerParameter filler = 3; + if (has_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->filler_); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BiasParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.BiasParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const BiasParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.BiasParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.BiasParameter) + UnsafeMergeFrom(*source); + } +} + +void BiasParameter::MergeFrom(const BiasParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.BiasParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void BiasParameter::UnsafeMergeFrom(const BiasParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_num_axes()) { + set_num_axes(from.num_axes()); + } + if (from.has_filler()) { + mutable_filler()->::caffe::FillerParameter::MergeFrom(from.filler()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void BiasParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.BiasParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BiasParameter::CopyFrom(const BiasParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.BiasParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool BiasParameter::IsInitialized() const { + + return true; +} + +void BiasParameter::Swap(BiasParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void BiasParameter::InternalSwap(BiasParameter* other) { + std::swap(axis_, other->axis_); + std::swap(num_axes_, other->num_axes_); + std::swap(filler_, other->filler_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata BiasParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BiasParameter_descriptor_; + metadata.reflection = BiasParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// BiasParameter + +// optional int32 axis = 1 [default = 1]; +bool BiasParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void BiasParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +void BiasParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +void BiasParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 BiasParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.BiasParameter.axis) + return axis_; +} +void BiasParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.BiasParameter.axis) +} + +// optional int32 num_axes = 2 [default = 1]; +bool BiasParameter::has_num_axes() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void BiasParameter::set_has_num_axes() { + _has_bits_[0] |= 0x00000002u; +} +void BiasParameter::clear_has_num_axes() { + _has_bits_[0] &= ~0x00000002u; +} +void BiasParameter::clear_num_axes() { + num_axes_ = 1; + clear_has_num_axes(); +} +::google::protobuf::int32 BiasParameter::num_axes() const { + // @@protoc_insertion_point(field_get:caffe.BiasParameter.num_axes) + return num_axes_; +} +void BiasParameter::set_num_axes(::google::protobuf::int32 value) { + set_has_num_axes(); + num_axes_ = value; + // @@protoc_insertion_point(field_set:caffe.BiasParameter.num_axes) +} + +// optional .caffe.FillerParameter filler = 3; +bool BiasParameter::has_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void BiasParameter::set_has_filler() { + _has_bits_[0] |= 0x00000004u; +} +void BiasParameter::clear_has_filler() { + _has_bits_[0] &= ~0x00000004u; +} +void BiasParameter::clear_filler() { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + clear_has_filler(); +} +const ::caffe::FillerParameter& BiasParameter::filler() const { + // @@protoc_insertion_point(field_get:caffe.BiasParameter.filler) + return filler_ != NULL ? *filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* BiasParameter::mutable_filler() { + set_has_filler(); + if (filler_ == NULL) { + filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.BiasParameter.filler) + return filler_; +} +::caffe::FillerParameter* BiasParameter::release_filler() { + // @@protoc_insertion_point(field_release:caffe.BiasParameter.filler) + clear_has_filler(); + ::caffe::FillerParameter* temp = filler_; + filler_ = NULL; + return temp; +} +void BiasParameter::set_allocated_filler(::caffe::FillerParameter* filler) { + delete filler_; + filler_ = filler; + if (filler) { + set_has_filler(); + } else { + clear_has_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.BiasParameter.filler) +} + +inline const BiasParameter* BiasParameter::internal_default_instance() { + return &BiasParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ContrastiveLossParameter::kMarginFieldNumber; +const int ContrastiveLossParameter::kLegacyVersionFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ContrastiveLossParameter::ContrastiveLossParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ContrastiveLossParameter) +} + +void ContrastiveLossParameter::InitAsDefaultInstance() { +} + +ContrastiveLossParameter::ContrastiveLossParameter(const ContrastiveLossParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ContrastiveLossParameter) +} + +void ContrastiveLossParameter::SharedCtor() { + _cached_size_ = 0; + legacy_version_ = false; + margin_ = 1; +} + +ContrastiveLossParameter::~ContrastiveLossParameter() { + // @@protoc_insertion_point(destructor:caffe.ContrastiveLossParameter) + SharedDtor(); +} + +void ContrastiveLossParameter::SharedDtor() { +} + +void ContrastiveLossParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ContrastiveLossParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ContrastiveLossParameter_descriptor_; +} + +const ContrastiveLossParameter& ContrastiveLossParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ContrastiveLossParameter_default_instance_; + +ContrastiveLossParameter* ContrastiveLossParameter::New(::google::protobuf::Arena* arena) const { + ContrastiveLossParameter* n = new ContrastiveLossParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ContrastiveLossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ContrastiveLossParameter) + if (_has_bits_[0 / 32] & 3u) { + margin_ = 1; + legacy_version_ = false; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ContrastiveLossParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ContrastiveLossParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float margin = 1 [default = 1]; + case 1: { + if (tag == 13) { + set_has_margin(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &margin_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_legacy_version; + break; + } + + // optional bool legacy_version = 2 [default = false]; + case 2: { + if (tag == 16) { + parse_legacy_version: + set_has_legacy_version(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &legacy_version_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ContrastiveLossParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ContrastiveLossParameter) + return false; +#undef DO_ +} + +void ContrastiveLossParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ContrastiveLossParameter) + // optional float margin = 1 [default = 1]; + if (has_margin()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->margin(), output); + } + + // optional bool legacy_version = 2 [default = false]; + if (has_legacy_version()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->legacy_version(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ContrastiveLossParameter) +} + +::google::protobuf::uint8* ContrastiveLossParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ContrastiveLossParameter) + // optional float margin = 1 [default = 1]; + if (has_margin()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->margin(), target); + } + + // optional bool legacy_version = 2 [default = false]; + if (has_legacy_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->legacy_version(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ContrastiveLossParameter) + return target; +} + +size_t ContrastiveLossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ContrastiveLossParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional float margin = 1 [default = 1]; + if (has_margin()) { + total_size += 1 + 4; + } + + // optional bool legacy_version = 2 [default = false]; + if (has_legacy_version()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ContrastiveLossParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ContrastiveLossParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ContrastiveLossParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ContrastiveLossParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ContrastiveLossParameter) + UnsafeMergeFrom(*source); + } +} + +void ContrastiveLossParameter::MergeFrom(const ContrastiveLossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ContrastiveLossParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ContrastiveLossParameter::UnsafeMergeFrom(const ContrastiveLossParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_margin()) { + set_margin(from.margin()); + } + if (from.has_legacy_version()) { + set_legacy_version(from.legacy_version()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ContrastiveLossParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ContrastiveLossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ContrastiveLossParameter::CopyFrom(const ContrastiveLossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ContrastiveLossParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ContrastiveLossParameter::IsInitialized() const { + + return true; +} + +void ContrastiveLossParameter::Swap(ContrastiveLossParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ContrastiveLossParameter::InternalSwap(ContrastiveLossParameter* other) { + std::swap(margin_, other->margin_); + std::swap(legacy_version_, other->legacy_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ContrastiveLossParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ContrastiveLossParameter_descriptor_; + metadata.reflection = ContrastiveLossParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ContrastiveLossParameter + +// optional float margin = 1 [default = 1]; +bool ContrastiveLossParameter::has_margin() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ContrastiveLossParameter::set_has_margin() { + _has_bits_[0] |= 0x00000001u; +} +void ContrastiveLossParameter::clear_has_margin() { + _has_bits_[0] &= ~0x00000001u; +} +void ContrastiveLossParameter::clear_margin() { + margin_ = 1; + clear_has_margin(); +} +float ContrastiveLossParameter::margin() const { + // @@protoc_insertion_point(field_get:caffe.ContrastiveLossParameter.margin) + return margin_; +} +void ContrastiveLossParameter::set_margin(float value) { + set_has_margin(); + margin_ = value; + // @@protoc_insertion_point(field_set:caffe.ContrastiveLossParameter.margin) +} + +// optional bool legacy_version = 2 [default = false]; +bool ContrastiveLossParameter::has_legacy_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ContrastiveLossParameter::set_has_legacy_version() { + _has_bits_[0] |= 0x00000002u; +} +void ContrastiveLossParameter::clear_has_legacy_version() { + _has_bits_[0] &= ~0x00000002u; +} +void ContrastiveLossParameter::clear_legacy_version() { + legacy_version_ = false; + clear_has_legacy_version(); +} +bool ContrastiveLossParameter::legacy_version() const { + // @@protoc_insertion_point(field_get:caffe.ContrastiveLossParameter.legacy_version) + return legacy_version_; +} +void ContrastiveLossParameter::set_legacy_version(bool value) { + set_has_legacy_version(); + legacy_version_ = value; + // @@protoc_insertion_point(field_set:caffe.ContrastiveLossParameter.legacy_version) +} + +inline const ContrastiveLossParameter* ContrastiveLossParameter::internal_default_instance() { + return &ContrastiveLossParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* ConvolutionParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConvolutionParameter_Engine_descriptor_; +} +bool ConvolutionParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const ConvolutionParameter_Engine ConvolutionParameter::DEFAULT; +const ConvolutionParameter_Engine ConvolutionParameter::CAFFE; +const ConvolutionParameter_Engine ConvolutionParameter::CUDNN; +const ConvolutionParameter_Engine ConvolutionParameter::Engine_MIN; +const ConvolutionParameter_Engine ConvolutionParameter::Engine_MAX; +const int ConvolutionParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ConvolutionParameter::kNumOutputFieldNumber; +const int ConvolutionParameter::kBiasTermFieldNumber; +const int ConvolutionParameter::kPadFieldNumber; +const int ConvolutionParameter::kKernelSizeFieldNumber; +const int ConvolutionParameter::kStrideFieldNumber; +const int ConvolutionParameter::kDilationFieldNumber; +const int ConvolutionParameter::kPadHFieldNumber; +const int ConvolutionParameter::kPadWFieldNumber; +const int ConvolutionParameter::kKernelHFieldNumber; +const int ConvolutionParameter::kKernelWFieldNumber; +const int ConvolutionParameter::kStrideHFieldNumber; +const int ConvolutionParameter::kStrideWFieldNumber; +const int ConvolutionParameter::kGroupFieldNumber; +const int ConvolutionParameter::kWeightFillerFieldNumber; +const int ConvolutionParameter::kBiasFillerFieldNumber; +const int ConvolutionParameter::kEngineFieldNumber; +const int ConvolutionParameter::kAxisFieldNumber; +const int ConvolutionParameter::kForceNdIm2ColFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ConvolutionParameter::ConvolutionParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ConvolutionParameter) +} + +void ConvolutionParameter::InitAsDefaultInstance() { + weight_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); + bias_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +ConvolutionParameter::ConvolutionParameter(const ConvolutionParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ConvolutionParameter) +} + +void ConvolutionParameter::SharedCtor() { + _cached_size_ = 0; + weight_filler_ = NULL; + bias_filler_ = NULL; + ::memset(&num_output_, 0, reinterpret_cast(&force_nd_im2col_) - + reinterpret_cast(&num_output_) + sizeof(force_nd_im2col_)); + axis_ = 1; + bias_term_ = true; + group_ = 1u; +} + +ConvolutionParameter::~ConvolutionParameter() { + // @@protoc_insertion_point(destructor:caffe.ConvolutionParameter) + SharedDtor(); +} + +void ConvolutionParameter::SharedDtor() { + if (this != &ConvolutionParameter_default_instance_.get()) { + delete weight_filler_; + delete bias_filler_; + } +} + +void ConvolutionParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ConvolutionParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConvolutionParameter_descriptor_; +} + +const ConvolutionParameter& ConvolutionParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ConvolutionParameter_default_instance_; + +ConvolutionParameter* ConvolutionParameter::New(::google::protobuf::Arena* arena) const { + ConvolutionParameter* n = new ConvolutionParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ConvolutionParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ConvolutionParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(ConvolutionParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 195u) { + ZR_(num_output_, pad_w_); + bias_term_ = true; + } + if (_has_bits_[8 / 32] & 65280u) { + ZR_(kernel_h_, engine_); + group_ = 1u; + if (has_weight_filler()) { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + } + if (has_bias_filler()) { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + } + } + if (_has_bits_[16 / 32] & 196608u) { + axis_ = 1; + force_nd_im2col_ = false; + } + +#undef ZR_HELPER_ +#undef ZR_ + + pad_.Clear(); + kernel_size_.Clear(); + stride_.Clear(); + dilation_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ConvolutionParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ConvolutionParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 num_output = 1; + case 1: { + if (tag == 8) { + set_has_num_output(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &num_output_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_bias_term; + break; + } + + // optional bool bias_term = 2 [default = true]; + case 2: { + if (tag == 16) { + parse_bias_term: + set_has_bias_term(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &bias_term_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_pad; + break; + } + + // repeated uint32 pad = 3; + case 3: { + if (tag == 24) { + parse_pad: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 24, input, this->mutable_pad()))); + } else if (tag == 26) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_pad()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_pad; + if (input->ExpectTag(32)) goto parse_kernel_size; + break; + } + + // repeated uint32 kernel_size = 4; + case 4: { + if (tag == 32) { + parse_kernel_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 32, input, this->mutable_kernel_size()))); + } else if (tag == 34) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_kernel_size()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_kernel_size; + if (input->ExpectTag(40)) goto parse_group; + break; + } + + // optional uint32 group = 5 [default = 1]; + case 5: { + if (tag == 40) { + parse_group: + set_has_group(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &group_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_stride; + break; + } + + // repeated uint32 stride = 6; + case 6: { + if (tag == 48) { + parse_stride: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 48, input, this->mutable_stride()))); + } else if (tag == 50) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_stride()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_stride; + if (input->ExpectTag(58)) goto parse_weight_filler; + break; + } + + // optional .caffe.FillerParameter weight_filler = 7; + case 7: { + if (tag == 58) { + parse_weight_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_weight_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_bias_filler; + break; + } + + // optional .caffe.FillerParameter bias_filler = 8; + case 8: { + if (tag == 66) { + parse_bias_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bias_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_pad_h; + break; + } + + // optional uint32 pad_h = 9 [default = 0]; + case 9: { + if (tag == 72) { + parse_pad_h: + set_has_pad_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &pad_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_pad_w; + break; + } + + // optional uint32 pad_w = 10 [default = 0]; + case 10: { + if (tag == 80) { + parse_pad_w: + set_has_pad_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &pad_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_kernel_h; + break; + } + + // optional uint32 kernel_h = 11; + case 11: { + if (tag == 88) { + parse_kernel_h: + set_has_kernel_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &kernel_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_kernel_w; + break; + } + + // optional uint32 kernel_w = 12; + case 12: { + if (tag == 96) { + parse_kernel_w: + set_has_kernel_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &kernel_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(104)) goto parse_stride_h; + break; + } + + // optional uint32 stride_h = 13; + case 13: { + if (tag == 104) { + parse_stride_h: + set_has_stride_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stride_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(112)) goto parse_stride_w; + break; + } + + // optional uint32 stride_w = 14; + case 14: { + if (tag == 112) { + parse_stride_w: + set_has_stride_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stride_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(120)) goto parse_engine; + break; + } + + // optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + case 15: { + if (tag == 120) { + parse_engine: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::ConvolutionParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::ConvolutionParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(15, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(128)) goto parse_axis; + break; + } + + // optional int32 axis = 16 [default = 1]; + case 16: { + if (tag == 128) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(136)) goto parse_force_nd_im2col; + break; + } + + // optional bool force_nd_im2col = 17 [default = false]; + case 17: { + if (tag == 136) { + parse_force_nd_im2col: + set_has_force_nd_im2col(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &force_nd_im2col_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(144)) goto parse_dilation; + break; + } + + // repeated uint32 dilation = 18; + case 18: { + if (tag == 144) { + parse_dilation: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 2, 144, input, this->mutable_dilation()))); + } else if (tag == 146) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_dilation()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(144)) goto parse_dilation; + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ConvolutionParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ConvolutionParameter) + return false; +#undef DO_ +} + +void ConvolutionParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ConvolutionParameter) + // optional uint32 num_output = 1; + if (has_num_output()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output); + } + + // optional bool bias_term = 2 [default = true]; + if (has_bias_term()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->bias_term(), output); + } + + // repeated uint32 pad = 3; + for (int i = 0; i < this->pad_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 3, this->pad(i), output); + } + + // repeated uint32 kernel_size = 4; + for (int i = 0; i < this->kernel_size_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 4, this->kernel_size(i), output); + } + + // optional uint32 group = 5 [default = 1]; + if (has_group()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->group(), output); + } + + // repeated uint32 stride = 6; + for (int i = 0; i < this->stride_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 6, this->stride(i), output); + } + + // optional .caffe.FillerParameter weight_filler = 7; + if (has_weight_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, *this->weight_filler_, output); + } + + // optional .caffe.FillerParameter bias_filler = 8; + if (has_bias_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, *this->bias_filler_, output); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (has_pad_h()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->pad_h(), output); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (has_pad_w()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->pad_w(), output); + } + + // optional uint32 kernel_h = 11; + if (has_kernel_h()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->kernel_h(), output); + } + + // optional uint32 kernel_w = 12; + if (has_kernel_w()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(12, this->kernel_w(), output); + } + + // optional uint32 stride_h = 13; + if (has_stride_h()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->stride_h(), output); + } + + // optional uint32 stride_w = 14; + if (has_stride_w()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(14, this->stride_w(), output); + } + + // optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 15, this->engine(), output); + } + + // optional int32 axis = 16 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(16, this->axis(), output); + } + + // optional bool force_nd_im2col = 17 [default = false]; + if (has_force_nd_im2col()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->force_nd_im2col(), output); + } + + // repeated uint32 dilation = 18; + for (int i = 0; i < this->dilation_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 18, this->dilation(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ConvolutionParameter) +} + +::google::protobuf::uint8* ConvolutionParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ConvolutionParameter) + // optional uint32 num_output = 1; + if (has_num_output()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target); + } + + // optional bool bias_term = 2 [default = true]; + if (has_bias_term()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->bias_term(), target); + } + + // repeated uint32 pad = 3; + for (int i = 0; i < this->pad_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(3, this->pad(i), target); + } + + // repeated uint32 kernel_size = 4; + for (int i = 0; i < this->kernel_size_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(4, this->kernel_size(i), target); + } + + // optional uint32 group = 5 [default = 1]; + if (has_group()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->group(), target); + } + + // repeated uint32 stride = 6; + for (int i = 0; i < this->stride_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(6, this->stride(i), target); + } + + // optional .caffe.FillerParameter weight_filler = 7; + if (has_weight_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 7, *this->weight_filler_, false, target); + } + + // optional .caffe.FillerParameter bias_filler = 8; + if (has_bias_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 8, *this->bias_filler_, false, target); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (has_pad_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->pad_h(), target); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (has_pad_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->pad_w(), target); + } + + // optional uint32 kernel_h = 11; + if (has_kernel_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->kernel_h(), target); + } + + // optional uint32 kernel_w = 12; + if (has_kernel_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(12, this->kernel_w(), target); + } + + // optional uint32 stride_h = 13; + if (has_stride_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->stride_h(), target); + } + + // optional uint32 stride_w = 14; + if (has_stride_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(14, this->stride_w(), target); + } + + // optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 15, this->engine(), target); + } + + // optional int32 axis = 16 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(16, this->axis(), target); + } + + // optional bool force_nd_im2col = 17 [default = false]; + if (has_force_nd_im2col()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->force_nd_im2col(), target); + } + + // repeated uint32 dilation = 18; + for (int i = 0; i < this->dilation_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(18, this->dilation(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ConvolutionParameter) + return target; +} + +size_t ConvolutionParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ConvolutionParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 195u) { + // optional uint32 num_output = 1; + if (has_num_output()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->num_output()); + } + + // optional bool bias_term = 2 [default = true]; + if (has_bias_term()) { + total_size += 1 + 1; + } + + // optional uint32 pad_h = 9 [default = 0]; + if (has_pad_h()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->pad_h()); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (has_pad_w()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->pad_w()); + } + + } + if (_has_bits_[8 / 32] & 65280u) { + // optional uint32 kernel_h = 11; + if (has_kernel_h()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->kernel_h()); + } + + // optional uint32 kernel_w = 12; + if (has_kernel_w()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->kernel_w()); + } + + // optional uint32 stride_h = 13; + if (has_stride_h()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stride_h()); + } + + // optional uint32 stride_w = 14; + if (has_stride_w()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stride_w()); + } + + // optional uint32 group = 5 [default = 1]; + if (has_group()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->group()); + } + + // optional .caffe.FillerParameter weight_filler = 7; + if (has_weight_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->weight_filler_); + } + + // optional .caffe.FillerParameter bias_filler = 8; + if (has_bias_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->bias_filler_); + } + + // optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + } + if (_has_bits_[16 / 32] & 196608u) { + // optional int32 axis = 16 [default = 1]; + if (has_axis()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional bool force_nd_im2col = 17 [default = false]; + if (has_force_nd_im2col()) { + total_size += 2 + 1; + } + + } + // repeated uint32 pad = 3; + { + size_t data_size = 0; + unsigned int count = this->pad_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->pad(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->pad_size()); + total_size += data_size; + } + + // repeated uint32 kernel_size = 4; + { + size_t data_size = 0; + unsigned int count = this->kernel_size_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->kernel_size(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->kernel_size_size()); + total_size += data_size; + } + + // repeated uint32 stride = 6; + { + size_t data_size = 0; + unsigned int count = this->stride_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->stride(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->stride_size()); + total_size += data_size; + } + + // repeated uint32 dilation = 18; + { + size_t data_size = 0; + unsigned int count = this->dilation_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->dilation(i)); + } + total_size += 2 * + ::google::protobuf::internal::FromIntSize(this->dilation_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ConvolutionParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ConvolutionParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ConvolutionParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ConvolutionParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ConvolutionParameter) + UnsafeMergeFrom(*source); + } +} + +void ConvolutionParameter::MergeFrom(const ConvolutionParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ConvolutionParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ConvolutionParameter::UnsafeMergeFrom(const ConvolutionParameter& from) { + GOOGLE_DCHECK(&from != this); + pad_.UnsafeMergeFrom(from.pad_); + kernel_size_.UnsafeMergeFrom(from.kernel_size_); + stride_.UnsafeMergeFrom(from.stride_); + dilation_.UnsafeMergeFrom(from.dilation_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_num_output()) { + set_num_output(from.num_output()); + } + if (from.has_bias_term()) { + set_bias_term(from.bias_term()); + } + if (from.has_pad_h()) { + set_pad_h(from.pad_h()); + } + if (from.has_pad_w()) { + set_pad_w(from.pad_w()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_kernel_h()) { + set_kernel_h(from.kernel_h()); + } + if (from.has_kernel_w()) { + set_kernel_w(from.kernel_w()); + } + if (from.has_stride_h()) { + set_stride_h(from.stride_h()); + } + if (from.has_stride_w()) { + set_stride_w(from.stride_w()); + } + if (from.has_group()) { + set_group(from.group()); + } + if (from.has_weight_filler()) { + mutable_weight_filler()->::caffe::FillerParameter::MergeFrom(from.weight_filler()); + } + if (from.has_bias_filler()) { + mutable_bias_filler()->::caffe::FillerParameter::MergeFrom(from.bias_filler()); + } + if (from.has_engine()) { + set_engine(from.engine()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_force_nd_im2col()) { + set_force_nd_im2col(from.force_nd_im2col()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ConvolutionParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ConvolutionParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ConvolutionParameter::CopyFrom(const ConvolutionParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ConvolutionParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ConvolutionParameter::IsInitialized() const { + + return true; +} + +void ConvolutionParameter::Swap(ConvolutionParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ConvolutionParameter::InternalSwap(ConvolutionParameter* other) { + std::swap(num_output_, other->num_output_); + std::swap(bias_term_, other->bias_term_); + pad_.UnsafeArenaSwap(&other->pad_); + kernel_size_.UnsafeArenaSwap(&other->kernel_size_); + stride_.UnsafeArenaSwap(&other->stride_); + dilation_.UnsafeArenaSwap(&other->dilation_); + std::swap(pad_h_, other->pad_h_); + std::swap(pad_w_, other->pad_w_); + std::swap(kernel_h_, other->kernel_h_); + std::swap(kernel_w_, other->kernel_w_); + std::swap(stride_h_, other->stride_h_); + std::swap(stride_w_, other->stride_w_); + std::swap(group_, other->group_); + std::swap(weight_filler_, other->weight_filler_); + std::swap(bias_filler_, other->bias_filler_); + std::swap(engine_, other->engine_); + std::swap(axis_, other->axis_); + std::swap(force_nd_im2col_, other->force_nd_im2col_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ConvolutionParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ConvolutionParameter_descriptor_; + metadata.reflection = ConvolutionParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ConvolutionParameter + +// optional uint32 num_output = 1; +bool ConvolutionParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ConvolutionParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +void ConvolutionParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +void ConvolutionParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +::google::protobuf::uint32 ConvolutionParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.num_output) + return num_output_; +} +void ConvolutionParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.num_output) +} + +// optional bool bias_term = 2 [default = true]; +bool ConvolutionParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ConvolutionParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000002u; +} +void ConvolutionParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000002u; +} +void ConvolutionParameter::clear_bias_term() { + bias_term_ = true; + clear_has_bias_term(); +} +bool ConvolutionParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.bias_term) + return bias_term_; +} +void ConvolutionParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.bias_term) +} + +// repeated uint32 pad = 3; +int ConvolutionParameter::pad_size() const { + return pad_.size(); +} +void ConvolutionParameter::clear_pad() { + pad_.Clear(); +} +::google::protobuf::uint32 ConvolutionParameter::pad(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad) + return pad_.Get(index); +} +void ConvolutionParameter::set_pad(int index, ::google::protobuf::uint32 value) { + pad_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad) +} +void ConvolutionParameter::add_pad(::google::protobuf::uint32 value) { + pad_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.pad) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::pad() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.pad) + return pad_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_pad() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.pad) + return &pad_; +} + +// repeated uint32 kernel_size = 4; +int ConvolutionParameter::kernel_size_size() const { + return kernel_size_.size(); +} +void ConvolutionParameter::clear_kernel_size() { + kernel_size_.Clear(); +} +::google::protobuf::uint32 ConvolutionParameter::kernel_size(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_size) + return kernel_size_.Get(index); +} +void ConvolutionParameter::set_kernel_size(int index, ::google::protobuf::uint32 value) { + kernel_size_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_size) +} +void ConvolutionParameter::add_kernel_size(::google::protobuf::uint32 value) { + kernel_size_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.kernel_size) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::kernel_size() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.kernel_size) + return kernel_size_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_kernel_size() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.kernel_size) + return &kernel_size_; +} + +// repeated uint32 stride = 6; +int ConvolutionParameter::stride_size() const { + return stride_.size(); +} +void ConvolutionParameter::clear_stride() { + stride_.Clear(); +} +::google::protobuf::uint32 ConvolutionParameter::stride(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride) + return stride_.Get(index); +} +void ConvolutionParameter::set_stride(int index, ::google::protobuf::uint32 value) { + stride_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride) +} +void ConvolutionParameter::add_stride(::google::protobuf::uint32 value) { + stride_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.stride) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::stride() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.stride) + return stride_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_stride() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.stride) + return &stride_; +} + +// repeated uint32 dilation = 18; +int ConvolutionParameter::dilation_size() const { + return dilation_.size(); +} +void ConvolutionParameter::clear_dilation() { + dilation_.Clear(); +} +::google::protobuf::uint32 ConvolutionParameter::dilation(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.dilation) + return dilation_.Get(index); +} +void ConvolutionParameter::set_dilation(int index, ::google::protobuf::uint32 value) { + dilation_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.dilation) +} +void ConvolutionParameter::add_dilation(::google::protobuf::uint32 value) { + dilation_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.dilation) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::dilation() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.dilation) + return dilation_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_dilation() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.dilation) + return &dilation_; +} + +// optional uint32 pad_h = 9 [default = 0]; +bool ConvolutionParameter::has_pad_h() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void ConvolutionParameter::set_has_pad_h() { + _has_bits_[0] |= 0x00000040u; +} +void ConvolutionParameter::clear_has_pad_h() { + _has_bits_[0] &= ~0x00000040u; +} +void ConvolutionParameter::clear_pad_h() { + pad_h_ = 0u; + clear_has_pad_h(); +} +::google::protobuf::uint32 ConvolutionParameter::pad_h() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad_h) + return pad_h_; +} +void ConvolutionParameter::set_pad_h(::google::protobuf::uint32 value) { + set_has_pad_h(); + pad_h_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad_h) +} + +// optional uint32 pad_w = 10 [default = 0]; +bool ConvolutionParameter::has_pad_w() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void ConvolutionParameter::set_has_pad_w() { + _has_bits_[0] |= 0x00000080u; +} +void ConvolutionParameter::clear_has_pad_w() { + _has_bits_[0] &= ~0x00000080u; +} +void ConvolutionParameter::clear_pad_w() { + pad_w_ = 0u; + clear_has_pad_w(); +} +::google::protobuf::uint32 ConvolutionParameter::pad_w() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad_w) + return pad_w_; +} +void ConvolutionParameter::set_pad_w(::google::protobuf::uint32 value) { + set_has_pad_w(); + pad_w_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad_w) +} + +// optional uint32 kernel_h = 11; +bool ConvolutionParameter::has_kernel_h() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void ConvolutionParameter::set_has_kernel_h() { + _has_bits_[0] |= 0x00000100u; +} +void ConvolutionParameter::clear_has_kernel_h() { + _has_bits_[0] &= ~0x00000100u; +} +void ConvolutionParameter::clear_kernel_h() { + kernel_h_ = 0u; + clear_has_kernel_h(); +} +::google::protobuf::uint32 ConvolutionParameter::kernel_h() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_h) + return kernel_h_; +} +void ConvolutionParameter::set_kernel_h(::google::protobuf::uint32 value) { + set_has_kernel_h(); + kernel_h_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_h) +} + +// optional uint32 kernel_w = 12; +bool ConvolutionParameter::has_kernel_w() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void ConvolutionParameter::set_has_kernel_w() { + _has_bits_[0] |= 0x00000200u; +} +void ConvolutionParameter::clear_has_kernel_w() { + _has_bits_[0] &= ~0x00000200u; +} +void ConvolutionParameter::clear_kernel_w() { + kernel_w_ = 0u; + clear_has_kernel_w(); +} +::google::protobuf::uint32 ConvolutionParameter::kernel_w() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_w) + return kernel_w_; +} +void ConvolutionParameter::set_kernel_w(::google::protobuf::uint32 value) { + set_has_kernel_w(); + kernel_w_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_w) +} + +// optional uint32 stride_h = 13; +bool ConvolutionParameter::has_stride_h() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +void ConvolutionParameter::set_has_stride_h() { + _has_bits_[0] |= 0x00000400u; +} +void ConvolutionParameter::clear_has_stride_h() { + _has_bits_[0] &= ~0x00000400u; +} +void ConvolutionParameter::clear_stride_h() { + stride_h_ = 0u; + clear_has_stride_h(); +} +::google::protobuf::uint32 ConvolutionParameter::stride_h() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride_h) + return stride_h_; +} +void ConvolutionParameter::set_stride_h(::google::protobuf::uint32 value) { + set_has_stride_h(); + stride_h_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride_h) +} + +// optional uint32 stride_w = 14; +bool ConvolutionParameter::has_stride_w() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void ConvolutionParameter::set_has_stride_w() { + _has_bits_[0] |= 0x00000800u; +} +void ConvolutionParameter::clear_has_stride_w() { + _has_bits_[0] &= ~0x00000800u; +} +void ConvolutionParameter::clear_stride_w() { + stride_w_ = 0u; + clear_has_stride_w(); +} +::google::protobuf::uint32 ConvolutionParameter::stride_w() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride_w) + return stride_w_; +} +void ConvolutionParameter::set_stride_w(::google::protobuf::uint32 value) { + set_has_stride_w(); + stride_w_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride_w) +} + +// optional uint32 group = 5 [default = 1]; +bool ConvolutionParameter::has_group() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +void ConvolutionParameter::set_has_group() { + _has_bits_[0] |= 0x00001000u; +} +void ConvolutionParameter::clear_has_group() { + _has_bits_[0] &= ~0x00001000u; +} +void ConvolutionParameter::clear_group() { + group_ = 1u; + clear_has_group(); +} +::google::protobuf::uint32 ConvolutionParameter::group() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.group) + return group_; +} +void ConvolutionParameter::set_group(::google::protobuf::uint32 value) { + set_has_group(); + group_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.group) +} + +// optional .caffe.FillerParameter weight_filler = 7; +bool ConvolutionParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +void ConvolutionParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00002000u; +} +void ConvolutionParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00002000u; +} +void ConvolutionParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +const ::caffe::FillerParameter& ConvolutionParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* ConvolutionParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ConvolutionParameter.weight_filler) + return weight_filler_; +} +::caffe::FillerParameter* ConvolutionParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.ConvolutionParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +void ConvolutionParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ConvolutionParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 8; +bool ConvolutionParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +void ConvolutionParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00004000u; +} +void ConvolutionParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00004000u; +} +void ConvolutionParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +const ::caffe::FillerParameter& ConvolutionParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* ConvolutionParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ConvolutionParameter.bias_filler) + return bias_filler_; +} +::caffe::FillerParameter* ConvolutionParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.ConvolutionParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +void ConvolutionParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ConvolutionParameter.bias_filler) +} + +// optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; +bool ConvolutionParameter::has_engine() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +void ConvolutionParameter::set_has_engine() { + _has_bits_[0] |= 0x00008000u; +} +void ConvolutionParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00008000u; +} +void ConvolutionParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::ConvolutionParameter_Engine ConvolutionParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.engine) + return static_cast< ::caffe::ConvolutionParameter_Engine >(engine_); +} +void ConvolutionParameter::set_engine(::caffe::ConvolutionParameter_Engine value) { + assert(::caffe::ConvolutionParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.engine) +} + +// optional int32 axis = 16 [default = 1]; +bool ConvolutionParameter::has_axis() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +void ConvolutionParameter::set_has_axis() { + _has_bits_[0] |= 0x00010000u; +} +void ConvolutionParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00010000u; +} +void ConvolutionParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 ConvolutionParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.axis) + return axis_; +} +void ConvolutionParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.axis) +} + +// optional bool force_nd_im2col = 17 [default = false]; +bool ConvolutionParameter::has_force_nd_im2col() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +void ConvolutionParameter::set_has_force_nd_im2col() { + _has_bits_[0] |= 0x00020000u; +} +void ConvolutionParameter::clear_has_force_nd_im2col() { + _has_bits_[0] &= ~0x00020000u; +} +void ConvolutionParameter::clear_force_nd_im2col() { + force_nd_im2col_ = false; + clear_has_force_nd_im2col(); +} +bool ConvolutionParameter::force_nd_im2col() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.force_nd_im2col) + return force_nd_im2col_; +} +void ConvolutionParameter::set_force_nd_im2col(bool value) { + set_has_force_nd_im2col(); + force_nd_im2col_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.force_nd_im2col) +} + +inline const ConvolutionParameter* ConvolutionParameter::internal_default_instance() { + return &ConvolutionParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int CropParameter::kAxisFieldNumber; +const int CropParameter::kOffsetFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +CropParameter::CropParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.CropParameter) +} + +void CropParameter::InitAsDefaultInstance() { +} + +CropParameter::CropParameter(const CropParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.CropParameter) +} + +void CropParameter::SharedCtor() { + _cached_size_ = 0; + axis_ = 2; +} + +CropParameter::~CropParameter() { + // @@protoc_insertion_point(destructor:caffe.CropParameter) + SharedDtor(); +} + +void CropParameter::SharedDtor() { +} + +void CropParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CropParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CropParameter_descriptor_; +} + +const CropParameter& CropParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed CropParameter_default_instance_; + +CropParameter* CropParameter::New(::google::protobuf::Arena* arena) const { + CropParameter* n = new CropParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void CropParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.CropParameter) + axis_ = 2; + offset_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool CropParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.CropParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 axis = 1 [default = 2]; + case 1: { + if (tag == 8) { + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // repeated uint32 offset = 2; + case 2: { + if (tag == 16) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 16, input, this->mutable_offset()))); + } else if (tag == 18) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_offset()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_offset; + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.CropParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.CropParameter) + return false; +#undef DO_ +} + +void CropParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.CropParameter) + // optional int32 axis = 1 [default = 2]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output); + } + + // repeated uint32 offset = 2; + for (int i = 0; i < this->offset_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 2, this->offset(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.CropParameter) +} + +::google::protobuf::uint8* CropParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.CropParameter) + // optional int32 axis = 1 [default = 2]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target); + } + + // repeated uint32 offset = 2; + for (int i = 0; i < this->offset_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(2, this->offset(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.CropParameter) + return target; +} + +size_t CropParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.CropParameter) + size_t total_size = 0; + + // optional int32 axis = 1 [default = 2]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // repeated uint32 offset = 2; + { + size_t data_size = 0; + unsigned int count = this->offset_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->offset(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->offset_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CropParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.CropParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const CropParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.CropParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.CropParameter) + UnsafeMergeFrom(*source); + } +} + +void CropParameter::MergeFrom(const CropParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.CropParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void CropParameter::UnsafeMergeFrom(const CropParameter& from) { + GOOGLE_DCHECK(&from != this); + offset_.UnsafeMergeFrom(from.offset_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void CropParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.CropParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CropParameter::CopyFrom(const CropParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.CropParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool CropParameter::IsInitialized() const { + + return true; +} + +void CropParameter::Swap(CropParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void CropParameter::InternalSwap(CropParameter* other) { + std::swap(axis_, other->axis_); + offset_.UnsafeArenaSwap(&other->offset_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata CropParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CropParameter_descriptor_; + metadata.reflection = CropParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// CropParameter + +// optional int32 axis = 1 [default = 2]; +bool CropParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void CropParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +void CropParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +void CropParameter::clear_axis() { + axis_ = 2; + clear_has_axis(); +} +::google::protobuf::int32 CropParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.CropParameter.axis) + return axis_; +} +void CropParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.CropParameter.axis) +} + +// repeated uint32 offset = 2; +int CropParameter::offset_size() const { + return offset_.size(); +} +void CropParameter::clear_offset() { + offset_.Clear(); +} +::google::protobuf::uint32 CropParameter::offset(int index) const { + // @@protoc_insertion_point(field_get:caffe.CropParameter.offset) + return offset_.Get(index); +} +void CropParameter::set_offset(int index, ::google::protobuf::uint32 value) { + offset_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.CropParameter.offset) +} +void CropParameter::add_offset(::google::protobuf::uint32 value) { + offset_.Add(value); + // @@protoc_insertion_point(field_add:caffe.CropParameter.offset) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +CropParameter::offset() const { + // @@protoc_insertion_point(field_list:caffe.CropParameter.offset) + return offset_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +CropParameter::mutable_offset() { + // @@protoc_insertion_point(field_mutable_list:caffe.CropParameter.offset) + return &offset_; +} + +inline const CropParameter* CropParameter::internal_default_instance() { + return &CropParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* DataParameter_DB_descriptor() { + protobuf_AssignDescriptorsOnce(); + return DataParameter_DB_descriptor_; +} +bool DataParameter_DB_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const DataParameter_DB DataParameter::LEVELDB; +const DataParameter_DB DataParameter::LMDB; +const DataParameter_DB DataParameter::DB_MIN; +const DataParameter_DB DataParameter::DB_MAX; +const int DataParameter::DB_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int DataParameter::kSourceFieldNumber; +const int DataParameter::kBatchSizeFieldNumber; +const int DataParameter::kRandSkipFieldNumber; +const int DataParameter::kBackendFieldNumber; +const int DataParameter::kScaleFieldNumber; +const int DataParameter::kMeanFileFieldNumber; +const int DataParameter::kCropSizeFieldNumber; +const int DataParameter::kMirrorFieldNumber; +const int DataParameter::kForceEncodedColorFieldNumber; +const int DataParameter::kPrefetchFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +DataParameter::DataParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.DataParameter) +} + +void DataParameter::InitAsDefaultInstance() { +} + +DataParameter::DataParameter(const DataParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.DataParameter) +} + +void DataParameter::SharedCtor() { + _cached_size_ = 0; + source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&batch_size_, 0, reinterpret_cast(&force_encoded_color_) - + reinterpret_cast(&batch_size_) + sizeof(force_encoded_color_)); + scale_ = 1; + prefetch_ = 4u; +} + +DataParameter::~DataParameter() { + // @@protoc_insertion_point(destructor:caffe.DataParameter) + SharedDtor(); +} + +void DataParameter::SharedDtor() { + source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void DataParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DataParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DataParameter_descriptor_; +} + +const DataParameter& DataParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed DataParameter_default_instance_; + +DataParameter* DataParameter::New(::google::protobuf::Arena* arena) const { + DataParameter* n = new DataParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void DataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.DataParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(DataParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 255u) { + ZR_(batch_size_, mirror_); + if (has_source()) { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + scale_ = 1; + if (has_mean_file()) { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + } + if (_has_bits_[8 / 32] & 768u) { + force_encoded_color_ = false; + prefetch_ = 4u; + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool DataParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.DataParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string source = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_source())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.DataParameter.source"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_scale; + break; + } + + // optional float scale = 2 [default = 1]; + case 2: { + if (tag == 21) { + parse_scale: + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_mean_file; + break; + } + + // optional string mean_file = 3; + case 3: { + if (tag == 26) { + parse_mean_file: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_mean_file())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.DataParameter.mean_file"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_batch_size; + break; + } + + // optional uint32 batch_size = 4; + case 4: { + if (tag == 32) { + parse_batch_size: + set_has_batch_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &batch_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_crop_size; + break; + } + + // optional uint32 crop_size = 5 [default = 0]; + case 5: { + if (tag == 40) { + parse_crop_size: + set_has_crop_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &crop_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_mirror; + break; + } + + // optional bool mirror = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_mirror: + set_has_mirror(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &mirror_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_rand_skip; + break; + } + + // optional uint32 rand_skip = 7 [default = 0]; + case 7: { + if (tag == 56) { + parse_rand_skip: + set_has_rand_skip(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &rand_skip_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_backend; + break; + } + + // optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + case 8: { + if (tag == 64) { + parse_backend: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::DataParameter_DB_IsValid(value)) { + set_backend(static_cast< ::caffe::DataParameter_DB >(value)); + } else { + mutable_unknown_fields()->AddVarint(8, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_force_encoded_color; + break; + } + + // optional bool force_encoded_color = 9 [default = false]; + case 9: { + if (tag == 72) { + parse_force_encoded_color: + set_has_force_encoded_color(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &force_encoded_color_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_prefetch; + break; + } + + // optional uint32 prefetch = 10 [default = 4]; + case 10: { + if (tag == 80) { + parse_prefetch: + set_has_prefetch(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &prefetch_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.DataParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.DataParameter) + return false; +#undef DO_ +} + +void DataParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.DataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.DataParameter.source"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->source(), output); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output); + } + + // optional string mean_file = 3; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.DataParameter.mean_file"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->mean_file(), output); + } + + // optional uint32 batch_size = 4; + if (has_batch_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->batch_size(), output); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->crop_size(), output); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->mirror(), output); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (has_rand_skip()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->rand_skip(), output); + } + + // optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + if (has_backend()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 8, this->backend(), output); + } + + // optional bool force_encoded_color = 9 [default = false]; + if (has_force_encoded_color()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->force_encoded_color(), output); + } + + // optional uint32 prefetch = 10 [default = 4]; + if (has_prefetch()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->prefetch(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.DataParameter) +} + +::google::protobuf::uint8* DataParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.DataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.DataParameter.source"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->source(), target); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target); + } + + // optional string mean_file = 3; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.DataParameter.mean_file"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->mean_file(), target); + } + + // optional uint32 batch_size = 4; + if (has_batch_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->batch_size(), target); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->crop_size(), target); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->mirror(), target); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (has_rand_skip()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->rand_skip(), target); + } + + // optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + if (has_backend()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 8, this->backend(), target); + } + + // optional bool force_encoded_color = 9 [default = false]; + if (has_force_encoded_color()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->force_encoded_color(), target); + } + + // optional uint32 prefetch = 10 [default = 4]; + if (has_prefetch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->prefetch(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.DataParameter) + return target; +} + +size_t DataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.DataParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional string source = 1; + if (has_source()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->source()); + } + + // optional uint32 batch_size = 4; + if (has_batch_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->batch_size()); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (has_rand_skip()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->rand_skip()); + } + + // optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + if (has_backend()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->backend()); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + total_size += 1 + 4; + } + + // optional string mean_file = 3; + if (has_mean_file()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->mean_file()); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->crop_size()); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + total_size += 1 + 1; + } + + } + if (_has_bits_[8 / 32] & 768u) { + // optional bool force_encoded_color = 9 [default = false]; + if (has_force_encoded_color()) { + total_size += 1 + 1; + } + + // optional uint32 prefetch = 10 [default = 4]; + if (has_prefetch()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->prefetch()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DataParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.DataParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const DataParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.DataParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.DataParameter) + UnsafeMergeFrom(*source); + } +} + +void DataParameter::MergeFrom(const DataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.DataParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void DataParameter::UnsafeMergeFrom(const DataParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_source()) { + set_has_source(); + source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_); + } + if (from.has_batch_size()) { + set_batch_size(from.batch_size()); + } + if (from.has_rand_skip()) { + set_rand_skip(from.rand_skip()); + } + if (from.has_backend()) { + set_backend(from.backend()); + } + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_mean_file()) { + set_has_mean_file(); + mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_); + } + if (from.has_crop_size()) { + set_crop_size(from.crop_size()); + } + if (from.has_mirror()) { + set_mirror(from.mirror()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_force_encoded_color()) { + set_force_encoded_color(from.force_encoded_color()); + } + if (from.has_prefetch()) { + set_prefetch(from.prefetch()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void DataParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.DataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DataParameter::CopyFrom(const DataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.DataParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool DataParameter::IsInitialized() const { + + return true; +} + +void DataParameter::Swap(DataParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void DataParameter::InternalSwap(DataParameter* other) { + source_.Swap(&other->source_); + std::swap(batch_size_, other->batch_size_); + std::swap(rand_skip_, other->rand_skip_); + std::swap(backend_, other->backend_); + std::swap(scale_, other->scale_); + mean_file_.Swap(&other->mean_file_); + std::swap(crop_size_, other->crop_size_); + std::swap(mirror_, other->mirror_); + std::swap(force_encoded_color_, other->force_encoded_color_); + std::swap(prefetch_, other->prefetch_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata DataParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DataParameter_descriptor_; + metadata.reflection = DataParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// DataParameter + +// optional string source = 1; +bool DataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void DataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +void DataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +void DataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +const ::std::string& DataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void DataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.DataParameter.source) +} +void DataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.DataParameter.source) +} +void DataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.DataParameter.source) +} +::std::string* DataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.DataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* DataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.DataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void DataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.DataParameter.source) +} + +// optional uint32 batch_size = 4; +bool DataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void DataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000002u; +} +void DataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000002u; +} +void DataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +::google::protobuf::uint32 DataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.batch_size) + return batch_size_; +} +void DataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.batch_size) +} + +// optional uint32 rand_skip = 7 [default = 0]; +bool DataParameter::has_rand_skip() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void DataParameter::set_has_rand_skip() { + _has_bits_[0] |= 0x00000004u; +} +void DataParameter::clear_has_rand_skip() { + _has_bits_[0] &= ~0x00000004u; +} +void DataParameter::clear_rand_skip() { + rand_skip_ = 0u; + clear_has_rand_skip(); +} +::google::protobuf::uint32 DataParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.rand_skip) + return rand_skip_; +} +void DataParameter::set_rand_skip(::google::protobuf::uint32 value) { + set_has_rand_skip(); + rand_skip_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.rand_skip) +} + +// optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB]; +bool DataParameter::has_backend() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void DataParameter::set_has_backend() { + _has_bits_[0] |= 0x00000008u; +} +void DataParameter::clear_has_backend() { + _has_bits_[0] &= ~0x00000008u; +} +void DataParameter::clear_backend() { + backend_ = 0; + clear_has_backend(); +} +::caffe::DataParameter_DB DataParameter::backend() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.backend) + return static_cast< ::caffe::DataParameter_DB >(backend_); +} +void DataParameter::set_backend(::caffe::DataParameter_DB value) { + assert(::caffe::DataParameter_DB_IsValid(value)); + set_has_backend(); + backend_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.backend) +} + +// optional float scale = 2 [default = 1]; +bool DataParameter::has_scale() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void DataParameter::set_has_scale() { + _has_bits_[0] |= 0x00000010u; +} +void DataParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000010u; +} +void DataParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float DataParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.scale) + return scale_; +} +void DataParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.scale) +} + +// optional string mean_file = 3; +bool DataParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void DataParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000020u; +} +void DataParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000020u; +} +void DataParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +const ::std::string& DataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void DataParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.DataParameter.mean_file) +} +void DataParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.DataParameter.mean_file) +} +void DataParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.DataParameter.mean_file) +} +::std::string* DataParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.DataParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* DataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.DataParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void DataParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.DataParameter.mean_file) +} + +// optional uint32 crop_size = 5 [default = 0]; +bool DataParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void DataParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000040u; +} +void DataParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000040u; +} +void DataParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +::google::protobuf::uint32 DataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.crop_size) + return crop_size_; +} +void DataParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +bool DataParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void DataParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000080u; +} +void DataParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000080u; +} +void DataParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +bool DataParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.mirror) + return mirror_; +} +void DataParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.mirror) +} + +// optional bool force_encoded_color = 9 [default = false]; +bool DataParameter::has_force_encoded_color() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void DataParameter::set_has_force_encoded_color() { + _has_bits_[0] |= 0x00000100u; +} +void DataParameter::clear_has_force_encoded_color() { + _has_bits_[0] &= ~0x00000100u; +} +void DataParameter::clear_force_encoded_color() { + force_encoded_color_ = false; + clear_has_force_encoded_color(); +} +bool DataParameter::force_encoded_color() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.force_encoded_color) + return force_encoded_color_; +} +void DataParameter::set_force_encoded_color(bool value) { + set_has_force_encoded_color(); + force_encoded_color_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.force_encoded_color) +} + +// optional uint32 prefetch = 10 [default = 4]; +bool DataParameter::has_prefetch() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void DataParameter::set_has_prefetch() { + _has_bits_[0] |= 0x00000200u; +} +void DataParameter::clear_has_prefetch() { + _has_bits_[0] &= ~0x00000200u; +} +void DataParameter::clear_prefetch() { + prefetch_ = 4u; + clear_has_prefetch(); +} +::google::protobuf::uint32 DataParameter::prefetch() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.prefetch) + return prefetch_; +} +void DataParameter::set_prefetch(::google::protobuf::uint32 value) { + set_has_prefetch(); + prefetch_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.prefetch) +} + +inline const DataParameter* DataParameter::internal_default_instance() { + return &DataParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NonMaximumSuppressionParameter::kNmsThresholdFieldNumber; +const int NonMaximumSuppressionParameter::kTopKFieldNumber; +const int NonMaximumSuppressionParameter::kEtaFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NonMaximumSuppressionParameter::NonMaximumSuppressionParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.NonMaximumSuppressionParameter) +} + +void NonMaximumSuppressionParameter::InitAsDefaultInstance() { +} + +NonMaximumSuppressionParameter::NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.NonMaximumSuppressionParameter) +} + +void NonMaximumSuppressionParameter::SharedCtor() { + _cached_size_ = 0; + top_k_ = 0; + nms_threshold_ = 0.3f; + eta_ = 1; +} + +NonMaximumSuppressionParameter::~NonMaximumSuppressionParameter() { + // @@protoc_insertion_point(destructor:caffe.NonMaximumSuppressionParameter) + SharedDtor(); +} + +void NonMaximumSuppressionParameter::SharedDtor() { +} + +void NonMaximumSuppressionParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NonMaximumSuppressionParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NonMaximumSuppressionParameter_descriptor_; +} + +const NonMaximumSuppressionParameter& NonMaximumSuppressionParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NonMaximumSuppressionParameter_default_instance_; + +NonMaximumSuppressionParameter* NonMaximumSuppressionParameter::New(::google::protobuf::Arena* arena) const { + NonMaximumSuppressionParameter* n = new NonMaximumSuppressionParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void NonMaximumSuppressionParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.NonMaximumSuppressionParameter) + if (_has_bits_[0 / 32] & 7u) { + nms_threshold_ = 0.3f; + top_k_ = 0; + eta_ = 1; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool NonMaximumSuppressionParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.NonMaximumSuppressionParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float nms_threshold = 1 [default = 0.3]; + case 1: { + if (tag == 13) { + set_has_nms_threshold(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &nms_threshold_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_top_k; + break; + } + + // optional int32 top_k = 2; + case 2: { + if (tag == 16) { + parse_top_k: + set_has_top_k(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &top_k_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_eta; + break; + } + + // optional float eta = 3 [default = 1]; + case 3: { + if (tag == 29) { + parse_eta: + set_has_eta(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &eta_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.NonMaximumSuppressionParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.NonMaximumSuppressionParameter) + return false; +#undef DO_ +} + +void NonMaximumSuppressionParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.NonMaximumSuppressionParameter) + // optional float nms_threshold = 1 [default = 0.3]; + if (has_nms_threshold()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->nms_threshold(), output); + } + + // optional int32 top_k = 2; + if (has_top_k()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->top_k(), output); + } + + // optional float eta = 3 [default = 1]; + if (has_eta()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->eta(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.NonMaximumSuppressionParameter) +} + +::google::protobuf::uint8* NonMaximumSuppressionParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.NonMaximumSuppressionParameter) + // optional float nms_threshold = 1 [default = 0.3]; + if (has_nms_threshold()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->nms_threshold(), target); + } + + // optional int32 top_k = 2; + if (has_top_k()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->top_k(), target); + } + + // optional float eta = 3 [default = 1]; + if (has_eta()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->eta(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.NonMaximumSuppressionParameter) + return target; +} + +size_t NonMaximumSuppressionParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.NonMaximumSuppressionParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional float nms_threshold = 1 [default = 0.3]; + if (has_nms_threshold()) { + total_size += 1 + 4; + } + + // optional int32 top_k = 2; + if (has_top_k()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->top_k()); + } + + // optional float eta = 3 [default = 1]; + if (has_eta()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NonMaximumSuppressionParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.NonMaximumSuppressionParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NonMaximumSuppressionParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.NonMaximumSuppressionParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.NonMaximumSuppressionParameter) + UnsafeMergeFrom(*source); + } +} + +void NonMaximumSuppressionParameter::MergeFrom(const NonMaximumSuppressionParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.NonMaximumSuppressionParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NonMaximumSuppressionParameter::UnsafeMergeFrom(const NonMaximumSuppressionParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_nms_threshold()) { + set_nms_threshold(from.nms_threshold()); + } + if (from.has_top_k()) { + set_top_k(from.top_k()); + } + if (from.has_eta()) { + set_eta(from.eta()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void NonMaximumSuppressionParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.NonMaximumSuppressionParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NonMaximumSuppressionParameter::CopyFrom(const NonMaximumSuppressionParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.NonMaximumSuppressionParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NonMaximumSuppressionParameter::IsInitialized() const { + + return true; +} + +void NonMaximumSuppressionParameter::Swap(NonMaximumSuppressionParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void NonMaximumSuppressionParameter::InternalSwap(NonMaximumSuppressionParameter* other) { + std::swap(nms_threshold_, other->nms_threshold_); + std::swap(top_k_, other->top_k_); + std::swap(eta_, other->eta_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NonMaximumSuppressionParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NonMaximumSuppressionParameter_descriptor_; + metadata.reflection = NonMaximumSuppressionParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NonMaximumSuppressionParameter + +// optional float nms_threshold = 1 [default = 0.3]; +bool NonMaximumSuppressionParameter::has_nms_threshold() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void NonMaximumSuppressionParameter::set_has_nms_threshold() { + _has_bits_[0] |= 0x00000001u; +} +void NonMaximumSuppressionParameter::clear_has_nms_threshold() { + _has_bits_[0] &= ~0x00000001u; +} +void NonMaximumSuppressionParameter::clear_nms_threshold() { + nms_threshold_ = 0.3f; + clear_has_nms_threshold(); +} +float NonMaximumSuppressionParameter::nms_threshold() const { + // @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.nms_threshold) + return nms_threshold_; +} +void NonMaximumSuppressionParameter::set_nms_threshold(float value) { + set_has_nms_threshold(); + nms_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.nms_threshold) +} + +// optional int32 top_k = 2; +bool NonMaximumSuppressionParameter::has_top_k() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void NonMaximumSuppressionParameter::set_has_top_k() { + _has_bits_[0] |= 0x00000002u; +} +void NonMaximumSuppressionParameter::clear_has_top_k() { + _has_bits_[0] &= ~0x00000002u; +} +void NonMaximumSuppressionParameter::clear_top_k() { + top_k_ = 0; + clear_has_top_k(); +} +::google::protobuf::int32 NonMaximumSuppressionParameter::top_k() const { + // @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.top_k) + return top_k_; +} +void NonMaximumSuppressionParameter::set_top_k(::google::protobuf::int32 value) { + set_has_top_k(); + top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.top_k) +} + +// optional float eta = 3 [default = 1]; +bool NonMaximumSuppressionParameter::has_eta() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void NonMaximumSuppressionParameter::set_has_eta() { + _has_bits_[0] |= 0x00000004u; +} +void NonMaximumSuppressionParameter::clear_has_eta() { + _has_bits_[0] &= ~0x00000004u; +} +void NonMaximumSuppressionParameter::clear_eta() { + eta_ = 1; + clear_has_eta(); +} +float NonMaximumSuppressionParameter::eta() const { + // @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.eta) + return eta_; +} +void NonMaximumSuppressionParameter::set_eta(float value) { + set_has_eta(); + eta_ = value; + // @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.eta) +} + +inline const NonMaximumSuppressionParameter* NonMaximumSuppressionParameter::internal_default_instance() { + return &NonMaximumSuppressionParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int SaveOutputParameter::kOutputDirectoryFieldNumber; +const int SaveOutputParameter::kOutputNamePrefixFieldNumber; +const int SaveOutputParameter::kOutputFormatFieldNumber; +const int SaveOutputParameter::kLabelMapFileFieldNumber; +const int SaveOutputParameter::kNameSizeFileFieldNumber; +const int SaveOutputParameter::kNumTestImageFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +SaveOutputParameter::SaveOutputParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.SaveOutputParameter) +} + +void SaveOutputParameter::InitAsDefaultInstance() { +} + +SaveOutputParameter::SaveOutputParameter(const SaveOutputParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.SaveOutputParameter) +} + +void SaveOutputParameter::SharedCtor() { + _cached_size_ = 0; + output_directory_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + output_name_prefix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + output_format_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + label_map_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + name_size_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + num_test_image_ = 0u; +} + +SaveOutputParameter::~SaveOutputParameter() { + // @@protoc_insertion_point(destructor:caffe.SaveOutputParameter) + SharedDtor(); +} + +void SaveOutputParameter::SharedDtor() { + output_directory_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + output_name_prefix_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + output_format_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + label_map_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + name_size_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void SaveOutputParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SaveOutputParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SaveOutputParameter_descriptor_; +} + +const SaveOutputParameter& SaveOutputParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed SaveOutputParameter_default_instance_; + +SaveOutputParameter* SaveOutputParameter::New(::google::protobuf::Arena* arena) const { + SaveOutputParameter* n = new SaveOutputParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void SaveOutputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.SaveOutputParameter) + if (_has_bits_[0 / 32] & 63u) { + if (has_output_directory()) { + output_directory_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_output_name_prefix()) { + output_name_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_output_format()) { + output_format_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_label_map_file()) { + label_map_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_name_size_file()) { + name_size_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + num_test_image_ = 0u; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool SaveOutputParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.SaveOutputParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string output_directory = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_output_directory())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_directory().data(), this->output_directory().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SaveOutputParameter.output_directory"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_output_name_prefix; + break; + } + + // optional string output_name_prefix = 2; + case 2: { + if (tag == 18) { + parse_output_name_prefix: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_output_name_prefix())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_name_prefix().data(), this->output_name_prefix().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SaveOutputParameter.output_name_prefix"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_output_format; + break; + } + + // optional string output_format = 3; + case 3: { + if (tag == 26) { + parse_output_format: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_output_format())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_format().data(), this->output_format().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SaveOutputParameter.output_format"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_label_map_file; + break; + } + + // optional string label_map_file = 4; + case 4: { + if (tag == 34) { + parse_label_map_file: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_label_map_file())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->label_map_file().data(), this->label_map_file().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SaveOutputParameter.label_map_file"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_name_size_file; + break; + } + + // optional string name_size_file = 5; + case 5: { + if (tag == 42) { + parse_name_size_file: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name_size_file())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name_size_file().data(), this->name_size_file().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.SaveOutputParameter.name_size_file"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_num_test_image; + break; + } + + // optional uint32 num_test_image = 6; + case 6: { + if (tag == 48) { + parse_num_test_image: + set_has_num_test_image(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &num_test_image_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.SaveOutputParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.SaveOutputParameter) + return false; +#undef DO_ +} + +void SaveOutputParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.SaveOutputParameter) + // optional string output_directory = 1; + if (has_output_directory()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_directory().data(), this->output_directory().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.output_directory"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->output_directory(), output); + } + + // optional string output_name_prefix = 2; + if (has_output_name_prefix()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_name_prefix().data(), this->output_name_prefix().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.output_name_prefix"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->output_name_prefix(), output); + } + + // optional string output_format = 3; + if (has_output_format()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_format().data(), this->output_format().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.output_format"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->output_format(), output); + } + + // optional string label_map_file = 4; + if (has_label_map_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->label_map_file().data(), this->label_map_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.label_map_file"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->label_map_file(), output); + } + + // optional string name_size_file = 5; + if (has_name_size_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name_size_file().data(), this->name_size_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.name_size_file"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->name_size_file(), output); + } + + // optional uint32 num_test_image = 6; + if (has_num_test_image()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->num_test_image(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.SaveOutputParameter) +} + +::google::protobuf::uint8* SaveOutputParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.SaveOutputParameter) + // optional string output_directory = 1; + if (has_output_directory()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_directory().data(), this->output_directory().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.output_directory"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->output_directory(), target); + } + + // optional string output_name_prefix = 2; + if (has_output_name_prefix()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_name_prefix().data(), this->output_name_prefix().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.output_name_prefix"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->output_name_prefix(), target); + } + + // optional string output_format = 3; + if (has_output_format()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output_format().data(), this->output_format().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.output_format"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->output_format(), target); + } + + // optional string label_map_file = 4; + if (has_label_map_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->label_map_file().data(), this->label_map_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.label_map_file"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->label_map_file(), target); + } + + // optional string name_size_file = 5; + if (has_name_size_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name_size_file().data(), this->name_size_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.SaveOutputParameter.name_size_file"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->name_size_file(), target); + } + + // optional uint32 num_test_image = 6; + if (has_num_test_image()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->num_test_image(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.SaveOutputParameter) + return target; +} + +size_t SaveOutputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.SaveOutputParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 63u) { + // optional string output_directory = 1; + if (has_output_directory()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->output_directory()); + } + + // optional string output_name_prefix = 2; + if (has_output_name_prefix()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->output_name_prefix()); + } + + // optional string output_format = 3; + if (has_output_format()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->output_format()); + } + + // optional string label_map_file = 4; + if (has_label_map_file()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->label_map_file()); + } + + // optional string name_size_file = 5; + if (has_name_size_file()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name_size_file()); + } + + // optional uint32 num_test_image = 6; + if (has_num_test_image()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->num_test_image()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SaveOutputParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.SaveOutputParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const SaveOutputParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.SaveOutputParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.SaveOutputParameter) + UnsafeMergeFrom(*source); + } +} + +void SaveOutputParameter::MergeFrom(const SaveOutputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.SaveOutputParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void SaveOutputParameter::UnsafeMergeFrom(const SaveOutputParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_output_directory()) { + set_has_output_directory(); + output_directory_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_directory_); + } + if (from.has_output_name_prefix()) { + set_has_output_name_prefix(); + output_name_prefix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_name_prefix_); + } + if (from.has_output_format()) { + set_has_output_format(); + output_format_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_format_); + } + if (from.has_label_map_file()) { + set_has_label_map_file(); + label_map_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.label_map_file_); + } + if (from.has_name_size_file()) { + set_has_name_size_file(); + name_size_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_size_file_); + } + if (from.has_num_test_image()) { + set_num_test_image(from.num_test_image()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void SaveOutputParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.SaveOutputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SaveOutputParameter::CopyFrom(const SaveOutputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.SaveOutputParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool SaveOutputParameter::IsInitialized() const { + + return true; +} + +void SaveOutputParameter::Swap(SaveOutputParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void SaveOutputParameter::InternalSwap(SaveOutputParameter* other) { + output_directory_.Swap(&other->output_directory_); + output_name_prefix_.Swap(&other->output_name_prefix_); + output_format_.Swap(&other->output_format_); + label_map_file_.Swap(&other->label_map_file_); + name_size_file_.Swap(&other->name_size_file_); + std::swap(num_test_image_, other->num_test_image_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata SaveOutputParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SaveOutputParameter_descriptor_; + metadata.reflection = SaveOutputParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// SaveOutputParameter + +// optional string output_directory = 1; +bool SaveOutputParameter::has_output_directory() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void SaveOutputParameter::set_has_output_directory() { + _has_bits_[0] |= 0x00000001u; +} +void SaveOutputParameter::clear_has_output_directory() { + _has_bits_[0] &= ~0x00000001u; +} +void SaveOutputParameter::clear_output_directory() { + output_directory_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_output_directory(); +} +const ::std::string& SaveOutputParameter::output_directory() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_directory) + return output_directory_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_output_directory(const ::std::string& value) { + set_has_output_directory(); + output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_directory) +} +void SaveOutputParameter::set_output_directory(const char* value) { + set_has_output_directory(); + output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.output_directory) +} +void SaveOutputParameter::set_output_directory(const char* value, size_t size) { + set_has_output_directory(); + output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.output_directory) +} +::std::string* SaveOutputParameter::mutable_output_directory() { + set_has_output_directory(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_directory) + return output_directory_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SaveOutputParameter::release_output_directory() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_directory) + clear_has_output_directory(); + return output_directory_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_allocated_output_directory(::std::string* output_directory) { + if (output_directory != NULL) { + set_has_output_directory(); + } else { + clear_has_output_directory(); + } + output_directory_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_directory); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_directory) +} + +// optional string output_name_prefix = 2; +bool SaveOutputParameter::has_output_name_prefix() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void SaveOutputParameter::set_has_output_name_prefix() { + _has_bits_[0] |= 0x00000002u; +} +void SaveOutputParameter::clear_has_output_name_prefix() { + _has_bits_[0] &= ~0x00000002u; +} +void SaveOutputParameter::clear_output_name_prefix() { + output_name_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_output_name_prefix(); +} +const ::std::string& SaveOutputParameter::output_name_prefix() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_name_prefix) + return output_name_prefix_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_output_name_prefix(const ::std::string& value) { + set_has_output_name_prefix(); + output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_name_prefix) +} +void SaveOutputParameter::set_output_name_prefix(const char* value) { + set_has_output_name_prefix(); + output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.output_name_prefix) +} +void SaveOutputParameter::set_output_name_prefix(const char* value, size_t size) { + set_has_output_name_prefix(); + output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.output_name_prefix) +} +::std::string* SaveOutputParameter::mutable_output_name_prefix() { + set_has_output_name_prefix(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_name_prefix) + return output_name_prefix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SaveOutputParameter::release_output_name_prefix() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_name_prefix) + clear_has_output_name_prefix(); + return output_name_prefix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_allocated_output_name_prefix(::std::string* output_name_prefix) { + if (output_name_prefix != NULL) { + set_has_output_name_prefix(); + } else { + clear_has_output_name_prefix(); + } + output_name_prefix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_name_prefix); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_name_prefix) +} + +// optional string output_format = 3; +bool SaveOutputParameter::has_output_format() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void SaveOutputParameter::set_has_output_format() { + _has_bits_[0] |= 0x00000004u; +} +void SaveOutputParameter::clear_has_output_format() { + _has_bits_[0] &= ~0x00000004u; +} +void SaveOutputParameter::clear_output_format() { + output_format_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_output_format(); +} +const ::std::string& SaveOutputParameter::output_format() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_format) + return output_format_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_output_format(const ::std::string& value) { + set_has_output_format(); + output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_format) +} +void SaveOutputParameter::set_output_format(const char* value) { + set_has_output_format(); + output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.output_format) +} +void SaveOutputParameter::set_output_format(const char* value, size_t size) { + set_has_output_format(); + output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.output_format) +} +::std::string* SaveOutputParameter::mutable_output_format() { + set_has_output_format(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_format) + return output_format_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SaveOutputParameter::release_output_format() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_format) + clear_has_output_format(); + return output_format_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_allocated_output_format(::std::string* output_format) { + if (output_format != NULL) { + set_has_output_format(); + } else { + clear_has_output_format(); + } + output_format_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_format); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_format) +} + +// optional string label_map_file = 4; +bool SaveOutputParameter::has_label_map_file() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void SaveOutputParameter::set_has_label_map_file() { + _has_bits_[0] |= 0x00000008u; +} +void SaveOutputParameter::clear_has_label_map_file() { + _has_bits_[0] &= ~0x00000008u; +} +void SaveOutputParameter::clear_label_map_file() { + label_map_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_label_map_file(); +} +const ::std::string& SaveOutputParameter::label_map_file() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.label_map_file) + return label_map_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_label_map_file(const ::std::string& value) { + set_has_label_map_file(); + label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.label_map_file) +} +void SaveOutputParameter::set_label_map_file(const char* value) { + set_has_label_map_file(); + label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.label_map_file) +} +void SaveOutputParameter::set_label_map_file(const char* value, size_t size) { + set_has_label_map_file(); + label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.label_map_file) +} +::std::string* SaveOutputParameter::mutable_label_map_file() { + set_has_label_map_file(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.label_map_file) + return label_map_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SaveOutputParameter::release_label_map_file() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.label_map_file) + clear_has_label_map_file(); + return label_map_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_allocated_label_map_file(::std::string* label_map_file) { + if (label_map_file != NULL) { + set_has_label_map_file(); + } else { + clear_has_label_map_file(); + } + label_map_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), label_map_file); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.label_map_file) +} + +// optional string name_size_file = 5; +bool SaveOutputParameter::has_name_size_file() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void SaveOutputParameter::set_has_name_size_file() { + _has_bits_[0] |= 0x00000010u; +} +void SaveOutputParameter::clear_has_name_size_file() { + _has_bits_[0] &= ~0x00000010u; +} +void SaveOutputParameter::clear_name_size_file() { + name_size_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name_size_file(); +} +const ::std::string& SaveOutputParameter::name_size_file() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.name_size_file) + return name_size_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_name_size_file(const ::std::string& value) { + set_has_name_size_file(); + name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.name_size_file) +} +void SaveOutputParameter::set_name_size_file(const char* value) { + set_has_name_size_file(); + name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.name_size_file) +} +void SaveOutputParameter::set_name_size_file(const char* value, size_t size) { + set_has_name_size_file(); + name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.name_size_file) +} +::std::string* SaveOutputParameter::mutable_name_size_file() { + set_has_name_size_file(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.name_size_file) + return name_size_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* SaveOutputParameter::release_name_size_file() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.name_size_file) + clear_has_name_size_file(); + return name_size_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void SaveOutputParameter::set_allocated_name_size_file(::std::string* name_size_file) { + if (name_size_file != NULL) { + set_has_name_size_file(); + } else { + clear_has_name_size_file(); + } + name_size_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name_size_file); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.name_size_file) +} + +// optional uint32 num_test_image = 6; +bool SaveOutputParameter::has_num_test_image() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void SaveOutputParameter::set_has_num_test_image() { + _has_bits_[0] |= 0x00000020u; +} +void SaveOutputParameter::clear_has_num_test_image() { + _has_bits_[0] &= ~0x00000020u; +} +void SaveOutputParameter::clear_num_test_image() { + num_test_image_ = 0u; + clear_has_num_test_image(); +} +::google::protobuf::uint32 SaveOutputParameter::num_test_image() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.num_test_image) + return num_test_image_; +} +void SaveOutputParameter::set_num_test_image(::google::protobuf::uint32 value) { + set_has_num_test_image(); + num_test_image_ = value; + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.num_test_image) +} + +inline const SaveOutputParameter* SaveOutputParameter::internal_default_instance() { + return &SaveOutputParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int DropoutParameter::kDropoutRatioFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +DropoutParameter::DropoutParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.DropoutParameter) +} + +void DropoutParameter::InitAsDefaultInstance() { +} + +DropoutParameter::DropoutParameter(const DropoutParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.DropoutParameter) +} + +void DropoutParameter::SharedCtor() { + _cached_size_ = 0; + dropout_ratio_ = 0.5f; +} + +DropoutParameter::~DropoutParameter() { + // @@protoc_insertion_point(destructor:caffe.DropoutParameter) + SharedDtor(); +} + +void DropoutParameter::SharedDtor() { +} + +void DropoutParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DropoutParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DropoutParameter_descriptor_; +} + +const DropoutParameter& DropoutParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed DropoutParameter_default_instance_; + +DropoutParameter* DropoutParameter::New(::google::protobuf::Arena* arena) const { + DropoutParameter* n = new DropoutParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void DropoutParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.DropoutParameter) + dropout_ratio_ = 0.5f; + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool DropoutParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.DropoutParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float dropout_ratio = 1 [default = 0.5]; + case 1: { + if (tag == 13) { + set_has_dropout_ratio(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &dropout_ratio_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.DropoutParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.DropoutParameter) + return false; +#undef DO_ +} + +void DropoutParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.DropoutParameter) + // optional float dropout_ratio = 1 [default = 0.5]; + if (has_dropout_ratio()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->dropout_ratio(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.DropoutParameter) +} + +::google::protobuf::uint8* DropoutParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.DropoutParameter) + // optional float dropout_ratio = 1 [default = 0.5]; + if (has_dropout_ratio()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->dropout_ratio(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.DropoutParameter) + return target; +} + +size_t DropoutParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.DropoutParameter) + size_t total_size = 0; + + // optional float dropout_ratio = 1 [default = 0.5]; + if (has_dropout_ratio()) { + total_size += 1 + 4; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DropoutParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.DropoutParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const DropoutParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.DropoutParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.DropoutParameter) + UnsafeMergeFrom(*source); + } +} + +void DropoutParameter::MergeFrom(const DropoutParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.DropoutParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void DropoutParameter::UnsafeMergeFrom(const DropoutParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_dropout_ratio()) { + set_dropout_ratio(from.dropout_ratio()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void DropoutParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.DropoutParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DropoutParameter::CopyFrom(const DropoutParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.DropoutParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool DropoutParameter::IsInitialized() const { + + return true; +} + +void DropoutParameter::Swap(DropoutParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void DropoutParameter::InternalSwap(DropoutParameter* other) { + std::swap(dropout_ratio_, other->dropout_ratio_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata DropoutParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DropoutParameter_descriptor_; + metadata.reflection = DropoutParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// DropoutParameter + +// optional float dropout_ratio = 1 [default = 0.5]; +bool DropoutParameter::has_dropout_ratio() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void DropoutParameter::set_has_dropout_ratio() { + _has_bits_[0] |= 0x00000001u; +} +void DropoutParameter::clear_has_dropout_ratio() { + _has_bits_[0] &= ~0x00000001u; +} +void DropoutParameter::clear_dropout_ratio() { + dropout_ratio_ = 0.5f; + clear_has_dropout_ratio(); +} +float DropoutParameter::dropout_ratio() const { + // @@protoc_insertion_point(field_get:caffe.DropoutParameter.dropout_ratio) + return dropout_ratio_; +} +void DropoutParameter::set_dropout_ratio(float value) { + set_has_dropout_ratio(); + dropout_ratio_ = value; + // @@protoc_insertion_point(field_set:caffe.DropoutParameter.dropout_ratio) +} + +inline const DropoutParameter* DropoutParameter::internal_default_instance() { + return &DropoutParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int DummyDataParameter::kDataFillerFieldNumber; +const int DummyDataParameter::kShapeFieldNumber; +const int DummyDataParameter::kNumFieldNumber; +const int DummyDataParameter::kChannelsFieldNumber; +const int DummyDataParameter::kHeightFieldNumber; +const int DummyDataParameter::kWidthFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +DummyDataParameter::DummyDataParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.DummyDataParameter) +} + +void DummyDataParameter::InitAsDefaultInstance() { +} + +DummyDataParameter::DummyDataParameter(const DummyDataParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.DummyDataParameter) +} + +void DummyDataParameter::SharedCtor() { + _cached_size_ = 0; +} + +DummyDataParameter::~DummyDataParameter() { + // @@protoc_insertion_point(destructor:caffe.DummyDataParameter) + SharedDtor(); +} + +void DummyDataParameter::SharedDtor() { +} + +void DummyDataParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DummyDataParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DummyDataParameter_descriptor_; +} + +const DummyDataParameter& DummyDataParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed DummyDataParameter_default_instance_; + +DummyDataParameter* DummyDataParameter::New(::google::protobuf::Arena* arena) const { + DummyDataParameter* n = new DummyDataParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void DummyDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.DummyDataParameter) + data_filler_.Clear(); + shape_.Clear(); + num_.Clear(); + channels_.Clear(); + height_.Clear(); + width_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool DummyDataParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.DummyDataParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .caffe.FillerParameter data_filler = 1; + case 1: { + if (tag == 10) { + DO_(input->IncrementRecursionDepth()); + parse_loop_data_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_data_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_loop_data_filler; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(16)) goto parse_num; + break; + } + + // repeated uint32 num = 2; + case 2: { + if (tag == 16) { + parse_num: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 16, input, this->mutable_num()))); + } else if (tag == 18) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_num()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_num; + if (input->ExpectTag(24)) goto parse_channels; + break; + } + + // repeated uint32 channels = 3; + case 3: { + if (tag == 24) { + parse_channels: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 24, input, this->mutable_channels()))); + } else if (tag == 26) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_channels()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_channels; + if (input->ExpectTag(32)) goto parse_height; + break; + } + + // repeated uint32 height = 4; + case 4: { + if (tag == 32) { + parse_height: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 32, input, this->mutable_height()))); + } else if (tag == 34) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_height()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_height; + if (input->ExpectTag(40)) goto parse_width; + break; + } + + // repeated uint32 width = 5; + case 5: { + if (tag == 40) { + parse_width: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 40, input, this->mutable_width()))); + } else if (tag == 42) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_width()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_width; + if (input->ExpectTag(50)) goto parse_shape; + break; + } + + // repeated .caffe.BlobShape shape = 6; + case 6: { + if (tag == 50) { + parse_shape: + DO_(input->IncrementRecursionDepth()); + parse_loop_shape: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_loop_shape; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.DummyDataParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.DummyDataParameter) + return false; +#undef DO_ +} + +void DummyDataParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.DummyDataParameter) + // repeated .caffe.FillerParameter data_filler = 1; + for (unsigned int i = 0, n = this->data_filler_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->data_filler(i), output); + } + + // repeated uint32 num = 2; + for (int i = 0; i < this->num_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 2, this->num(i), output); + } + + // repeated uint32 channels = 3; + for (int i = 0; i < this->channels_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 3, this->channels(i), output); + } + + // repeated uint32 height = 4; + for (int i = 0; i < this->height_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 4, this->height(i), output); + } + + // repeated uint32 width = 5; + for (int i = 0; i < this->width_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 5, this->width(i), output); + } + + // repeated .caffe.BlobShape shape = 6; + for (unsigned int i = 0, n = this->shape_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->shape(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.DummyDataParameter) +} + +::google::protobuf::uint8* DummyDataParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.DummyDataParameter) + // repeated .caffe.FillerParameter data_filler = 1; + for (unsigned int i = 0, n = this->data_filler_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, this->data_filler(i), false, target); + } + + // repeated uint32 num = 2; + for (int i = 0; i < this->num_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(2, this->num(i), target); + } + + // repeated uint32 channels = 3; + for (int i = 0; i < this->channels_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(3, this->channels(i), target); + } + + // repeated uint32 height = 4; + for (int i = 0; i < this->height_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(4, this->height(i), target); + } + + // repeated uint32 width = 5; + for (int i = 0; i < this->width_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(5, this->width(i), target); + } + + // repeated .caffe.BlobShape shape = 6; + for (unsigned int i = 0, n = this->shape_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 6, this->shape(i), false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.DummyDataParameter) + return target; +} + +size_t DummyDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.DummyDataParameter) + size_t total_size = 0; + + // repeated .caffe.FillerParameter data_filler = 1; + { + unsigned int count = this->data_filler_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->data_filler(i)); + } + } + + // repeated .caffe.BlobShape shape = 6; + { + unsigned int count = this->shape_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->shape(i)); + } + } + + // repeated uint32 num = 2; + { + size_t data_size = 0; + unsigned int count = this->num_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->num(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->num_size()); + total_size += data_size; + } + + // repeated uint32 channels = 3; + { + size_t data_size = 0; + unsigned int count = this->channels_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->channels(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->channels_size()); + total_size += data_size; + } + + // repeated uint32 height = 4; + { + size_t data_size = 0; + unsigned int count = this->height_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->height(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->height_size()); + total_size += data_size; + } + + // repeated uint32 width = 5; + { + size_t data_size = 0; + unsigned int count = this->width_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->width(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->width_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DummyDataParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.DummyDataParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const DummyDataParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.DummyDataParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.DummyDataParameter) + UnsafeMergeFrom(*source); + } +} + +void DummyDataParameter::MergeFrom(const DummyDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.DummyDataParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void DummyDataParameter::UnsafeMergeFrom(const DummyDataParameter& from) { + GOOGLE_DCHECK(&from != this); + data_filler_.MergeFrom(from.data_filler_); + shape_.MergeFrom(from.shape_); + num_.UnsafeMergeFrom(from.num_); + channels_.UnsafeMergeFrom(from.channels_); + height_.UnsafeMergeFrom(from.height_); + width_.UnsafeMergeFrom(from.width_); + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void DummyDataParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.DummyDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DummyDataParameter::CopyFrom(const DummyDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.DummyDataParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool DummyDataParameter::IsInitialized() const { + + return true; +} + +void DummyDataParameter::Swap(DummyDataParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void DummyDataParameter::InternalSwap(DummyDataParameter* other) { + data_filler_.UnsafeArenaSwap(&other->data_filler_); + shape_.UnsafeArenaSwap(&other->shape_); + num_.UnsafeArenaSwap(&other->num_); + channels_.UnsafeArenaSwap(&other->channels_); + height_.UnsafeArenaSwap(&other->height_); + width_.UnsafeArenaSwap(&other->width_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata DummyDataParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DummyDataParameter_descriptor_; + metadata.reflection = DummyDataParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// DummyDataParameter + +// repeated .caffe.FillerParameter data_filler = 1; +int DummyDataParameter::data_filler_size() const { + return data_filler_.size(); +} +void DummyDataParameter::clear_data_filler() { + data_filler_.Clear(); +} +const ::caffe::FillerParameter& DummyDataParameter::data_filler(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.data_filler) + return data_filler_.Get(index); +} +::caffe::FillerParameter* DummyDataParameter::mutable_data_filler(int index) { + // @@protoc_insertion_point(field_mutable:caffe.DummyDataParameter.data_filler) + return data_filler_.Mutable(index); +} +::caffe::FillerParameter* DummyDataParameter::add_data_filler() { + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.data_filler) + return data_filler_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >* +DummyDataParameter::mutable_data_filler() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.data_filler) + return &data_filler_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >& +DummyDataParameter::data_filler() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.data_filler) + return data_filler_; +} + +// repeated .caffe.BlobShape shape = 6; +int DummyDataParameter::shape_size() const { + return shape_.size(); +} +void DummyDataParameter::clear_shape() { + shape_.Clear(); +} +const ::caffe::BlobShape& DummyDataParameter::shape(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.shape) + return shape_.Get(index); +} +::caffe::BlobShape* DummyDataParameter::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:caffe.DummyDataParameter.shape) + return shape_.Mutable(index); +} +::caffe::BlobShape* DummyDataParameter::add_shape() { + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.shape) + return shape_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* +DummyDataParameter::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.shape) + return &shape_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& +DummyDataParameter::shape() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.shape) + return shape_; +} + +// repeated uint32 num = 2; +int DummyDataParameter::num_size() const { + return num_.size(); +} +void DummyDataParameter::clear_num() { + num_.Clear(); +} +::google::protobuf::uint32 DummyDataParameter::num(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.num) + return num_.Get(index); +} +void DummyDataParameter::set_num(int index, ::google::protobuf::uint32 value) { + num_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.num) +} +void DummyDataParameter::add_num(::google::protobuf::uint32 value) { + num_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.num) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::num() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.num) + return num_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_num() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.num) + return &num_; +} + +// repeated uint32 channels = 3; +int DummyDataParameter::channels_size() const { + return channels_.size(); +} +void DummyDataParameter::clear_channels() { + channels_.Clear(); +} +::google::protobuf::uint32 DummyDataParameter::channels(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.channels) + return channels_.Get(index); +} +void DummyDataParameter::set_channels(int index, ::google::protobuf::uint32 value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.channels) +} +void DummyDataParameter::add_channels(::google::protobuf::uint32 value) { + channels_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.channels) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::channels() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.channels) + return channels_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.channels) + return &channels_; +} + +// repeated uint32 height = 4; +int DummyDataParameter::height_size() const { + return height_.size(); +} +void DummyDataParameter::clear_height() { + height_.Clear(); +} +::google::protobuf::uint32 DummyDataParameter::height(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.height) + return height_.Get(index); +} +void DummyDataParameter::set_height(int index, ::google::protobuf::uint32 value) { + height_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.height) +} +void DummyDataParameter::add_height(::google::protobuf::uint32 value) { + height_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.height) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::height() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.height) + return height_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_height() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.height) + return &height_; +} + +// repeated uint32 width = 5; +int DummyDataParameter::width_size() const { + return width_.size(); +} +void DummyDataParameter::clear_width() { + width_.Clear(); +} +::google::protobuf::uint32 DummyDataParameter::width(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.width) + return width_.Get(index); +} +void DummyDataParameter::set_width(int index, ::google::protobuf::uint32 value) { + width_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.width) +} +void DummyDataParameter::add_width(::google::protobuf::uint32 value) { + width_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.width) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::width() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.width) + return width_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_width() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.width) + return &width_; +} + +inline const DummyDataParameter* DummyDataParameter::internal_default_instance() { + return &DummyDataParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor() { + protobuf_AssignDescriptorsOnce(); + return EltwiseParameter_EltwiseOp_descriptor_; +} +bool EltwiseParameter_EltwiseOp_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const EltwiseParameter_EltwiseOp EltwiseParameter::PROD; +const EltwiseParameter_EltwiseOp EltwiseParameter::SUM; +const EltwiseParameter_EltwiseOp EltwiseParameter::MAX; +const EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MIN; +const EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MAX; +const int EltwiseParameter::EltwiseOp_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int EltwiseParameter::kOperationFieldNumber; +const int EltwiseParameter::kCoeffFieldNumber; +const int EltwiseParameter::kStableProdGradFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +EltwiseParameter::EltwiseParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.EltwiseParameter) +} + +void EltwiseParameter::InitAsDefaultInstance() { +} + +EltwiseParameter::EltwiseParameter(const EltwiseParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.EltwiseParameter) +} + +void EltwiseParameter::SharedCtor() { + _cached_size_ = 0; + operation_ = 1; + stable_prod_grad_ = true; +} + +EltwiseParameter::~EltwiseParameter() { + // @@protoc_insertion_point(destructor:caffe.EltwiseParameter) + SharedDtor(); +} + +void EltwiseParameter::SharedDtor() { +} + +void EltwiseParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* EltwiseParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return EltwiseParameter_descriptor_; +} + +const EltwiseParameter& EltwiseParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed EltwiseParameter_default_instance_; + +EltwiseParameter* EltwiseParameter::New(::google::protobuf::Arena* arena) const { + EltwiseParameter* n = new EltwiseParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void EltwiseParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.EltwiseParameter) + if (_has_bits_[0 / 32] & 5u) { + operation_ = 1; + stable_prod_grad_ = true; + } + coeff_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool EltwiseParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.EltwiseParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::EltwiseParameter_EltwiseOp_IsValid(value)) { + set_operation(static_cast< ::caffe::EltwiseParameter_EltwiseOp >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_coeff; + break; + } + + // repeated float coeff = 2; + case 2: { + if (tag == 21) { + parse_coeff: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 21, input, this->mutable_coeff()))); + } else if (tag == 18) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_coeff()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_coeff; + if (input->ExpectTag(24)) goto parse_stable_prod_grad; + break; + } + + // optional bool stable_prod_grad = 3 [default = true]; + case 3: { + if (tag == 24) { + parse_stable_prod_grad: + set_has_stable_prod_grad(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &stable_prod_grad_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.EltwiseParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.EltwiseParameter) + return false; +#undef DO_ +} + +void EltwiseParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.EltwiseParameter) + // optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + if (has_operation()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->operation(), output); + } + + // repeated float coeff = 2; + for (int i = 0; i < this->coeff_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 2, this->coeff(i), output); + } + + // optional bool stable_prod_grad = 3 [default = true]; + if (has_stable_prod_grad()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->stable_prod_grad(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.EltwiseParameter) +} + +::google::protobuf::uint8* EltwiseParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.EltwiseParameter) + // optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + if (has_operation()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->operation(), target); + } + + // repeated float coeff = 2; + for (int i = 0; i < this->coeff_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(2, this->coeff(i), target); + } + + // optional bool stable_prod_grad = 3 [default = true]; + if (has_stable_prod_grad()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->stable_prod_grad(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.EltwiseParameter) + return target; +} + +size_t EltwiseParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.EltwiseParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 5u) { + // optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + if (has_operation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation()); + } + + // optional bool stable_prod_grad = 3 [default = true]; + if (has_stable_prod_grad()) { + total_size += 1 + 1; + } + + } + // repeated float coeff = 2; + { + size_t data_size = 0; + unsigned int count = this->coeff_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->coeff_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void EltwiseParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.EltwiseParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const EltwiseParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.EltwiseParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.EltwiseParameter) + UnsafeMergeFrom(*source); + } +} + +void EltwiseParameter::MergeFrom(const EltwiseParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.EltwiseParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void EltwiseParameter::UnsafeMergeFrom(const EltwiseParameter& from) { + GOOGLE_DCHECK(&from != this); + coeff_.UnsafeMergeFrom(from.coeff_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_operation()) { + set_operation(from.operation()); + } + if (from.has_stable_prod_grad()) { + set_stable_prod_grad(from.stable_prod_grad()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void EltwiseParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.EltwiseParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EltwiseParameter::CopyFrom(const EltwiseParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.EltwiseParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool EltwiseParameter::IsInitialized() const { + + return true; +} + +void EltwiseParameter::Swap(EltwiseParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void EltwiseParameter::InternalSwap(EltwiseParameter* other) { + std::swap(operation_, other->operation_); + coeff_.UnsafeArenaSwap(&other->coeff_); + std::swap(stable_prod_grad_, other->stable_prod_grad_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata EltwiseParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = EltwiseParameter_descriptor_; + metadata.reflection = EltwiseParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// EltwiseParameter + +// optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; +bool EltwiseParameter::has_operation() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void EltwiseParameter::set_has_operation() { + _has_bits_[0] |= 0x00000001u; +} +void EltwiseParameter::clear_has_operation() { + _has_bits_[0] &= ~0x00000001u; +} +void EltwiseParameter::clear_operation() { + operation_ = 1; + clear_has_operation(); +} +::caffe::EltwiseParameter_EltwiseOp EltwiseParameter::operation() const { + // @@protoc_insertion_point(field_get:caffe.EltwiseParameter.operation) + return static_cast< ::caffe::EltwiseParameter_EltwiseOp >(operation_); +} +void EltwiseParameter::set_operation(::caffe::EltwiseParameter_EltwiseOp value) { + assert(::caffe::EltwiseParameter_EltwiseOp_IsValid(value)); + set_has_operation(); + operation_ = value; + // @@protoc_insertion_point(field_set:caffe.EltwiseParameter.operation) +} + +// repeated float coeff = 2; +int EltwiseParameter::coeff_size() const { + return coeff_.size(); +} +void EltwiseParameter::clear_coeff() { + coeff_.Clear(); +} +float EltwiseParameter::coeff(int index) const { + // @@protoc_insertion_point(field_get:caffe.EltwiseParameter.coeff) + return coeff_.Get(index); +} +void EltwiseParameter::set_coeff(int index, float value) { + coeff_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.EltwiseParameter.coeff) +} +void EltwiseParameter::add_coeff(float value) { + coeff_.Add(value); + // @@protoc_insertion_point(field_add:caffe.EltwiseParameter.coeff) +} +const ::google::protobuf::RepeatedField< float >& +EltwiseParameter::coeff() const { + // @@protoc_insertion_point(field_list:caffe.EltwiseParameter.coeff) + return coeff_; +} +::google::protobuf::RepeatedField< float >* +EltwiseParameter::mutable_coeff() { + // @@protoc_insertion_point(field_mutable_list:caffe.EltwiseParameter.coeff) + return &coeff_; +} + +// optional bool stable_prod_grad = 3 [default = true]; +bool EltwiseParameter::has_stable_prod_grad() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void EltwiseParameter::set_has_stable_prod_grad() { + _has_bits_[0] |= 0x00000004u; +} +void EltwiseParameter::clear_has_stable_prod_grad() { + _has_bits_[0] &= ~0x00000004u; +} +void EltwiseParameter::clear_stable_prod_grad() { + stable_prod_grad_ = true; + clear_has_stable_prod_grad(); +} +bool EltwiseParameter::stable_prod_grad() const { + // @@protoc_insertion_point(field_get:caffe.EltwiseParameter.stable_prod_grad) + return stable_prod_grad_; +} +void EltwiseParameter::set_stable_prod_grad(bool value) { + set_has_stable_prod_grad(); + stable_prod_grad_ = value; + // @@protoc_insertion_point(field_set:caffe.EltwiseParameter.stable_prod_grad) +} + +inline const EltwiseParameter* EltwiseParameter::internal_default_instance() { + return &EltwiseParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ELUParameter::kAlphaFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ELUParameter::ELUParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ELUParameter) +} + +void ELUParameter::InitAsDefaultInstance() { +} + +ELUParameter::ELUParameter(const ELUParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ELUParameter) +} + +void ELUParameter::SharedCtor() { + _cached_size_ = 0; + alpha_ = 1; +} + +ELUParameter::~ELUParameter() { + // @@protoc_insertion_point(destructor:caffe.ELUParameter) + SharedDtor(); +} + +void ELUParameter::SharedDtor() { +} + +void ELUParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ELUParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ELUParameter_descriptor_; +} + +const ELUParameter& ELUParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ELUParameter_default_instance_; + +ELUParameter* ELUParameter::New(::google::protobuf::Arena* arena) const { + ELUParameter* n = new ELUParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ELUParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ELUParameter) + alpha_ = 1; + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ELUParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ELUParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float alpha = 1 [default = 1]; + case 1: { + if (tag == 13) { + set_has_alpha(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &alpha_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ELUParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ELUParameter) + return false; +#undef DO_ +} + +void ELUParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ELUParameter) + // optional float alpha = 1 [default = 1]; + if (has_alpha()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->alpha(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ELUParameter) +} + +::google::protobuf::uint8* ELUParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ELUParameter) + // optional float alpha = 1 [default = 1]; + if (has_alpha()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->alpha(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ELUParameter) + return target; +} + +size_t ELUParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ELUParameter) + size_t total_size = 0; + + // optional float alpha = 1 [default = 1]; + if (has_alpha()) { + total_size += 1 + 4; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ELUParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ELUParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ELUParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ELUParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ELUParameter) + UnsafeMergeFrom(*source); + } +} + +void ELUParameter::MergeFrom(const ELUParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ELUParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ELUParameter::UnsafeMergeFrom(const ELUParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_alpha()) { + set_alpha(from.alpha()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ELUParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ELUParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ELUParameter::CopyFrom(const ELUParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ELUParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ELUParameter::IsInitialized() const { + + return true; +} + +void ELUParameter::Swap(ELUParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ELUParameter::InternalSwap(ELUParameter* other) { + std::swap(alpha_, other->alpha_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ELUParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ELUParameter_descriptor_; + metadata.reflection = ELUParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ELUParameter + +// optional float alpha = 1 [default = 1]; +bool ELUParameter::has_alpha() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ELUParameter::set_has_alpha() { + _has_bits_[0] |= 0x00000001u; +} +void ELUParameter::clear_has_alpha() { + _has_bits_[0] &= ~0x00000001u; +} +void ELUParameter::clear_alpha() { + alpha_ = 1; + clear_has_alpha(); +} +float ELUParameter::alpha() const { + // @@protoc_insertion_point(field_get:caffe.ELUParameter.alpha) + return alpha_; +} +void ELUParameter::set_alpha(float value) { + set_has_alpha(); + alpha_ = value; + // @@protoc_insertion_point(field_set:caffe.ELUParameter.alpha) +} + +inline const ELUParameter* ELUParameter::internal_default_instance() { + return &ELUParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int EmbedParameter::kNumOutputFieldNumber; +const int EmbedParameter::kInputDimFieldNumber; +const int EmbedParameter::kBiasTermFieldNumber; +const int EmbedParameter::kWeightFillerFieldNumber; +const int EmbedParameter::kBiasFillerFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +EmbedParameter::EmbedParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.EmbedParameter) +} + +void EmbedParameter::InitAsDefaultInstance() { + weight_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); + bias_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +EmbedParameter::EmbedParameter(const EmbedParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.EmbedParameter) +} + +void EmbedParameter::SharedCtor() { + _cached_size_ = 0; + weight_filler_ = NULL; + bias_filler_ = NULL; + ::memset(&num_output_, 0, reinterpret_cast(&input_dim_) - + reinterpret_cast(&num_output_) + sizeof(input_dim_)); + bias_term_ = true; +} + +EmbedParameter::~EmbedParameter() { + // @@protoc_insertion_point(destructor:caffe.EmbedParameter) + SharedDtor(); +} + +void EmbedParameter::SharedDtor() { + if (this != &EmbedParameter_default_instance_.get()) { + delete weight_filler_; + delete bias_filler_; + } +} + +void EmbedParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* EmbedParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return EmbedParameter_descriptor_; +} + +const EmbedParameter& EmbedParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed EmbedParameter_default_instance_; + +EmbedParameter* EmbedParameter::New(::google::protobuf::Arena* arena) const { + EmbedParameter* n = new EmbedParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void EmbedParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.EmbedParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(EmbedParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 31u) { + ZR_(num_output_, input_dim_); + bias_term_ = true; + if (has_weight_filler()) { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + } + if (has_bias_filler()) { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool EmbedParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.EmbedParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 num_output = 1; + case 1: { + if (tag == 8) { + set_has_num_output(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &num_output_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_input_dim; + break; + } + + // optional uint32 input_dim = 2; + case 2: { + if (tag == 16) { + parse_input_dim: + set_has_input_dim(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &input_dim_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_bias_term; + break; + } + + // optional bool bias_term = 3 [default = true]; + case 3: { + if (tag == 24) { + parse_bias_term: + set_has_bias_term(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &bias_term_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_weight_filler; + break; + } + + // optional .caffe.FillerParameter weight_filler = 4; + case 4: { + if (tag == 34) { + parse_weight_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_weight_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_bias_filler; + break; + } + + // optional .caffe.FillerParameter bias_filler = 5; + case 5: { + if (tag == 42) { + parse_bias_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bias_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.EmbedParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.EmbedParameter) + return false; +#undef DO_ +} + +void EmbedParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.EmbedParameter) + // optional uint32 num_output = 1; + if (has_num_output()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output); + } + + // optional uint32 input_dim = 2; + if (has_input_dim()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->input_dim(), output); + } + + // optional bool bias_term = 3 [default = true]; + if (has_bias_term()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->bias_term(), output); + } + + // optional .caffe.FillerParameter weight_filler = 4; + if (has_weight_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, *this->weight_filler_, output); + } + + // optional .caffe.FillerParameter bias_filler = 5; + if (has_bias_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *this->bias_filler_, output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.EmbedParameter) +} + +::google::protobuf::uint8* EmbedParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.EmbedParameter) + // optional uint32 num_output = 1; + if (has_num_output()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target); + } + + // optional uint32 input_dim = 2; + if (has_input_dim()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->input_dim(), target); + } + + // optional bool bias_term = 3 [default = true]; + if (has_bias_term()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->bias_term(), target); + } + + // optional .caffe.FillerParameter weight_filler = 4; + if (has_weight_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 4, *this->weight_filler_, false, target); + } + + // optional .caffe.FillerParameter bias_filler = 5; + if (has_bias_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *this->bias_filler_, false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.EmbedParameter) + return target; +} + +size_t EmbedParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.EmbedParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 31u) { + // optional uint32 num_output = 1; + if (has_num_output()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->num_output()); + } + + // optional uint32 input_dim = 2; + if (has_input_dim()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->input_dim()); + } + + // optional bool bias_term = 3 [default = true]; + if (has_bias_term()) { + total_size += 1 + 1; + } + + // optional .caffe.FillerParameter weight_filler = 4; + if (has_weight_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->weight_filler_); + } + + // optional .caffe.FillerParameter bias_filler = 5; + if (has_bias_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->bias_filler_); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void EmbedParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.EmbedParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const EmbedParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.EmbedParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.EmbedParameter) + UnsafeMergeFrom(*source); + } +} + +void EmbedParameter::MergeFrom(const EmbedParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.EmbedParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void EmbedParameter::UnsafeMergeFrom(const EmbedParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_num_output()) { + set_num_output(from.num_output()); + } + if (from.has_input_dim()) { + set_input_dim(from.input_dim()); + } + if (from.has_bias_term()) { + set_bias_term(from.bias_term()); + } + if (from.has_weight_filler()) { + mutable_weight_filler()->::caffe::FillerParameter::MergeFrom(from.weight_filler()); + } + if (from.has_bias_filler()) { + mutable_bias_filler()->::caffe::FillerParameter::MergeFrom(from.bias_filler()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void EmbedParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.EmbedParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EmbedParameter::CopyFrom(const EmbedParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.EmbedParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool EmbedParameter::IsInitialized() const { + + return true; +} + +void EmbedParameter::Swap(EmbedParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void EmbedParameter::InternalSwap(EmbedParameter* other) { + std::swap(num_output_, other->num_output_); + std::swap(input_dim_, other->input_dim_); + std::swap(bias_term_, other->bias_term_); + std::swap(weight_filler_, other->weight_filler_); + std::swap(bias_filler_, other->bias_filler_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata EmbedParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = EmbedParameter_descriptor_; + metadata.reflection = EmbedParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// EmbedParameter + +// optional uint32 num_output = 1; +bool EmbedParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void EmbedParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +void EmbedParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +void EmbedParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +::google::protobuf::uint32 EmbedParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.num_output) + return num_output_; +} +void EmbedParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.EmbedParameter.num_output) +} + +// optional uint32 input_dim = 2; +bool EmbedParameter::has_input_dim() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void EmbedParameter::set_has_input_dim() { + _has_bits_[0] |= 0x00000002u; +} +void EmbedParameter::clear_has_input_dim() { + _has_bits_[0] &= ~0x00000002u; +} +void EmbedParameter::clear_input_dim() { + input_dim_ = 0u; + clear_has_input_dim(); +} +::google::protobuf::uint32 EmbedParameter::input_dim() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.input_dim) + return input_dim_; +} +void EmbedParameter::set_input_dim(::google::protobuf::uint32 value) { + set_has_input_dim(); + input_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.EmbedParameter.input_dim) +} + +// optional bool bias_term = 3 [default = true]; +bool EmbedParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void EmbedParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000004u; +} +void EmbedParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000004u; +} +void EmbedParameter::clear_bias_term() { + bias_term_ = true; + clear_has_bias_term(); +} +bool EmbedParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.bias_term) + return bias_term_; +} +void EmbedParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.EmbedParameter.bias_term) +} + +// optional .caffe.FillerParameter weight_filler = 4; +bool EmbedParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void EmbedParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000008u; +} +void EmbedParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000008u; +} +void EmbedParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +const ::caffe::FillerParameter& EmbedParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* EmbedParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.EmbedParameter.weight_filler) + return weight_filler_; +} +::caffe::FillerParameter* EmbedParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.EmbedParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +void EmbedParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.EmbedParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 5; +bool EmbedParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void EmbedParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000010u; +} +void EmbedParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000010u; +} +void EmbedParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +const ::caffe::FillerParameter& EmbedParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* EmbedParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.EmbedParameter.bias_filler) + return bias_filler_; +} +::caffe::FillerParameter* EmbedParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.EmbedParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +void EmbedParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.EmbedParameter.bias_filler) +} + +inline const EmbedParameter* EmbedParameter::internal_default_instance() { + return &EmbedParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ExpParameter::kBaseFieldNumber; +const int ExpParameter::kScaleFieldNumber; +const int ExpParameter::kShiftFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ExpParameter::ExpParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ExpParameter) +} + +void ExpParameter::InitAsDefaultInstance() { +} + +ExpParameter::ExpParameter(const ExpParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ExpParameter) +} + +void ExpParameter::SharedCtor() { + _cached_size_ = 0; + shift_ = 0; + base_ = -1; + scale_ = 1; +} + +ExpParameter::~ExpParameter() { + // @@protoc_insertion_point(destructor:caffe.ExpParameter) + SharedDtor(); +} + +void ExpParameter::SharedDtor() { +} + +void ExpParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ExpParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ExpParameter_descriptor_; +} + +const ExpParameter& ExpParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ExpParameter_default_instance_; + +ExpParameter* ExpParameter::New(::google::protobuf::Arena* arena) const { + ExpParameter* n = new ExpParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ExpParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ExpParameter) + if (_has_bits_[0 / 32] & 7u) { + base_ = -1; + scale_ = 1; + shift_ = 0; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ExpParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ExpParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float base = 1 [default = -1]; + case 1: { + if (tag == 13) { + set_has_base(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &base_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_scale; + break; + } + + // optional float scale = 2 [default = 1]; + case 2: { + if (tag == 21) { + parse_scale: + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_shift; + break; + } + + // optional float shift = 3 [default = 0]; + case 3: { + if (tag == 29) { + parse_shift: + set_has_shift(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &shift_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ExpParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ExpParameter) + return false; +#undef DO_ +} + +void ExpParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ExpParameter) + // optional float base = 1 [default = -1]; + if (has_base()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->base(), output); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output); + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->shift(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ExpParameter) +} + +::google::protobuf::uint8* ExpParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ExpParameter) + // optional float base = 1 [default = -1]; + if (has_base()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->base(), target); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target); + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->shift(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ExpParameter) + return target; +} + +size_t ExpParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ExpParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional float base = 1 [default = -1]; + if (has_base()) { + total_size += 1 + 4; + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + total_size += 1 + 4; + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ExpParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ExpParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ExpParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ExpParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ExpParameter) + UnsafeMergeFrom(*source); + } +} + +void ExpParameter::MergeFrom(const ExpParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ExpParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ExpParameter::UnsafeMergeFrom(const ExpParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_base()) { + set_base(from.base()); + } + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_shift()) { + set_shift(from.shift()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ExpParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ExpParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ExpParameter::CopyFrom(const ExpParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ExpParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ExpParameter::IsInitialized() const { + + return true; +} + +void ExpParameter::Swap(ExpParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ExpParameter::InternalSwap(ExpParameter* other) { + std::swap(base_, other->base_); + std::swap(scale_, other->scale_); + std::swap(shift_, other->shift_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ExpParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ExpParameter_descriptor_; + metadata.reflection = ExpParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ExpParameter + +// optional float base = 1 [default = -1]; +bool ExpParameter::has_base() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ExpParameter::set_has_base() { + _has_bits_[0] |= 0x00000001u; +} +void ExpParameter::clear_has_base() { + _has_bits_[0] &= ~0x00000001u; +} +void ExpParameter::clear_base() { + base_ = -1; + clear_has_base(); +} +float ExpParameter::base() const { + // @@protoc_insertion_point(field_get:caffe.ExpParameter.base) + return base_; +} +void ExpParameter::set_base(float value) { + set_has_base(); + base_ = value; + // @@protoc_insertion_point(field_set:caffe.ExpParameter.base) +} + +// optional float scale = 2 [default = 1]; +bool ExpParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ExpParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +void ExpParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +void ExpParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float ExpParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.ExpParameter.scale) + return scale_; +} +void ExpParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.ExpParameter.scale) +} + +// optional float shift = 3 [default = 0]; +bool ExpParameter::has_shift() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void ExpParameter::set_has_shift() { + _has_bits_[0] |= 0x00000004u; +} +void ExpParameter::clear_has_shift() { + _has_bits_[0] &= ~0x00000004u; +} +void ExpParameter::clear_shift() { + shift_ = 0; + clear_has_shift(); +} +float ExpParameter::shift() const { + // @@protoc_insertion_point(field_get:caffe.ExpParameter.shift) + return shift_; +} +void ExpParameter::set_shift(float value) { + set_has_shift(); + shift_ = value; + // @@protoc_insertion_point(field_set:caffe.ExpParameter.shift) +} + +inline const ExpParameter* ExpParameter::internal_default_instance() { + return &ExpParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int FlattenParameter::kAxisFieldNumber; +const int FlattenParameter::kEndAxisFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +FlattenParameter::FlattenParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.FlattenParameter) +} + +void FlattenParameter::InitAsDefaultInstance() { +} + +FlattenParameter::FlattenParameter(const FlattenParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.FlattenParameter) +} + +void FlattenParameter::SharedCtor() { + _cached_size_ = 0; + axis_ = 1; + end_axis_ = -1; +} + +FlattenParameter::~FlattenParameter() { + // @@protoc_insertion_point(destructor:caffe.FlattenParameter) + SharedDtor(); +} + +void FlattenParameter::SharedDtor() { +} + +void FlattenParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FlattenParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FlattenParameter_descriptor_; +} + +const FlattenParameter& FlattenParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed FlattenParameter_default_instance_; + +FlattenParameter* FlattenParameter::New(::google::protobuf::Arena* arena) const { + FlattenParameter* n = new FlattenParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void FlattenParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.FlattenParameter) + if (_has_bits_[0 / 32] & 3u) { + axis_ = 1; + end_axis_ = -1; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool FlattenParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.FlattenParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 axis = 1 [default = 1]; + case 1: { + if (tag == 8) { + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_end_axis; + break; + } + + // optional int32 end_axis = 2 [default = -1]; + case 2: { + if (tag == 16) { + parse_end_axis: + set_has_end_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &end_axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.FlattenParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.FlattenParameter) + return false; +#undef DO_ +} + +void FlattenParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.FlattenParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output); + } + + // optional int32 end_axis = 2 [default = -1]; + if (has_end_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->end_axis(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.FlattenParameter) +} + +::google::protobuf::uint8* FlattenParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.FlattenParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target); + } + + // optional int32 end_axis = 2 [default = -1]; + if (has_end_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->end_axis(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.FlattenParameter) + return target; +} + +size_t FlattenParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.FlattenParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional int32 end_axis = 2 [default = -1]; + if (has_end_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->end_axis()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FlattenParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.FlattenParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const FlattenParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.FlattenParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.FlattenParameter) + UnsafeMergeFrom(*source); + } +} + +void FlattenParameter::MergeFrom(const FlattenParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.FlattenParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void FlattenParameter::UnsafeMergeFrom(const FlattenParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_end_axis()) { + set_end_axis(from.end_axis()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void FlattenParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.FlattenParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FlattenParameter::CopyFrom(const FlattenParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.FlattenParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool FlattenParameter::IsInitialized() const { + + return true; +} + +void FlattenParameter::Swap(FlattenParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void FlattenParameter::InternalSwap(FlattenParameter* other) { + std::swap(axis_, other->axis_); + std::swap(end_axis_, other->end_axis_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata FlattenParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FlattenParameter_descriptor_; + metadata.reflection = FlattenParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// FlattenParameter + +// optional int32 axis = 1 [default = 1]; +bool FlattenParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void FlattenParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +void FlattenParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +void FlattenParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 FlattenParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.FlattenParameter.axis) + return axis_; +} +void FlattenParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.FlattenParameter.axis) +} + +// optional int32 end_axis = 2 [default = -1]; +bool FlattenParameter::has_end_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void FlattenParameter::set_has_end_axis() { + _has_bits_[0] |= 0x00000002u; +} +void FlattenParameter::clear_has_end_axis() { + _has_bits_[0] &= ~0x00000002u; +} +void FlattenParameter::clear_end_axis() { + end_axis_ = -1; + clear_has_end_axis(); +} +::google::protobuf::int32 FlattenParameter::end_axis() const { + // @@protoc_insertion_point(field_get:caffe.FlattenParameter.end_axis) + return end_axis_; +} +void FlattenParameter::set_end_axis(::google::protobuf::int32 value) { + set_has_end_axis(); + end_axis_ = value; + // @@protoc_insertion_point(field_set:caffe.FlattenParameter.end_axis) +} + +inline const FlattenParameter* FlattenParameter::internal_default_instance() { + return &FlattenParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int HDF5DataParameter::kSourceFieldNumber; +const int HDF5DataParameter::kBatchSizeFieldNumber; +const int HDF5DataParameter::kShuffleFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +HDF5DataParameter::HDF5DataParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.HDF5DataParameter) +} + +void HDF5DataParameter::InitAsDefaultInstance() { +} + +HDF5DataParameter::HDF5DataParameter(const HDF5DataParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.HDF5DataParameter) +} + +void HDF5DataParameter::SharedCtor() { + _cached_size_ = 0; + source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&batch_size_, 0, reinterpret_cast(&shuffle_) - + reinterpret_cast(&batch_size_) + sizeof(shuffle_)); +} + +HDF5DataParameter::~HDF5DataParameter() { + // @@protoc_insertion_point(destructor:caffe.HDF5DataParameter) + SharedDtor(); +} + +void HDF5DataParameter::SharedDtor() { + source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void HDF5DataParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* HDF5DataParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return HDF5DataParameter_descriptor_; +} + +const HDF5DataParameter& HDF5DataParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed HDF5DataParameter_default_instance_; + +HDF5DataParameter* HDF5DataParameter::New(::google::protobuf::Arena* arena) const { + HDF5DataParameter* n = new HDF5DataParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void HDF5DataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.HDF5DataParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(HDF5DataParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 7u) { + ZR_(batch_size_, shuffle_); + if (has_source()) { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool HDF5DataParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.HDF5DataParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string source = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_source())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.HDF5DataParameter.source"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_batch_size; + break; + } + + // optional uint32 batch_size = 2; + case 2: { + if (tag == 16) { + parse_batch_size: + set_has_batch_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &batch_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_shuffle; + break; + } + + // optional bool shuffle = 3 [default = false]; + case 3: { + if (tag == 24) { + parse_shuffle: + set_has_shuffle(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &shuffle_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.HDF5DataParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.HDF5DataParameter) + return false; +#undef DO_ +} + +void HDF5DataParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.HDF5DataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.HDF5DataParameter.source"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->source(), output); + } + + // optional uint32 batch_size = 2; + if (has_batch_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->batch_size(), output); + } + + // optional bool shuffle = 3 [default = false]; + if (has_shuffle()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->shuffle(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.HDF5DataParameter) +} + +::google::protobuf::uint8* HDF5DataParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.HDF5DataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.HDF5DataParameter.source"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->source(), target); + } + + // optional uint32 batch_size = 2; + if (has_batch_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->batch_size(), target); + } + + // optional bool shuffle = 3 [default = false]; + if (has_shuffle()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->shuffle(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.HDF5DataParameter) + return target; +} + +size_t HDF5DataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.HDF5DataParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional string source = 1; + if (has_source()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->source()); + } + + // optional uint32 batch_size = 2; + if (has_batch_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->batch_size()); + } + + // optional bool shuffle = 3 [default = false]; + if (has_shuffle()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void HDF5DataParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.HDF5DataParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const HDF5DataParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.HDF5DataParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.HDF5DataParameter) + UnsafeMergeFrom(*source); + } +} + +void HDF5DataParameter::MergeFrom(const HDF5DataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.HDF5DataParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void HDF5DataParameter::UnsafeMergeFrom(const HDF5DataParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_source()) { + set_has_source(); + source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_); + } + if (from.has_batch_size()) { + set_batch_size(from.batch_size()); + } + if (from.has_shuffle()) { + set_shuffle(from.shuffle()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void HDF5DataParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.HDF5DataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HDF5DataParameter::CopyFrom(const HDF5DataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.HDF5DataParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool HDF5DataParameter::IsInitialized() const { + + return true; +} + +void HDF5DataParameter::Swap(HDF5DataParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void HDF5DataParameter::InternalSwap(HDF5DataParameter* other) { + source_.Swap(&other->source_); + std::swap(batch_size_, other->batch_size_); + std::swap(shuffle_, other->shuffle_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata HDF5DataParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = HDF5DataParameter_descriptor_; + metadata.reflection = HDF5DataParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// HDF5DataParameter + +// optional string source = 1; +bool HDF5DataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void HDF5DataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +void HDF5DataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +void HDF5DataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +const ::std::string& HDF5DataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void HDF5DataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.source) +} +void HDF5DataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.HDF5DataParameter.source) +} +void HDF5DataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.HDF5DataParameter.source) +} +::std::string* HDF5DataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.HDF5DataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* HDF5DataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.HDF5DataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void HDF5DataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.HDF5DataParameter.source) +} + +// optional uint32 batch_size = 2; +bool HDF5DataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void HDF5DataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000002u; +} +void HDF5DataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000002u; +} +void HDF5DataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +::google::protobuf::uint32 HDF5DataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.batch_size) + return batch_size_; +} +void HDF5DataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.batch_size) +} + +// optional bool shuffle = 3 [default = false]; +bool HDF5DataParameter::has_shuffle() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void HDF5DataParameter::set_has_shuffle() { + _has_bits_[0] |= 0x00000004u; +} +void HDF5DataParameter::clear_has_shuffle() { + _has_bits_[0] &= ~0x00000004u; +} +void HDF5DataParameter::clear_shuffle() { + shuffle_ = false; + clear_has_shuffle(); +} +bool HDF5DataParameter::shuffle() const { + // @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.shuffle) + return shuffle_; +} +void HDF5DataParameter::set_shuffle(bool value) { + set_has_shuffle(); + shuffle_ = value; + // @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.shuffle) +} + +inline const HDF5DataParameter* HDF5DataParameter::internal_default_instance() { + return &HDF5DataParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int HDF5OutputParameter::kFileNameFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +HDF5OutputParameter::HDF5OutputParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.HDF5OutputParameter) +} + +void HDF5OutputParameter::InitAsDefaultInstance() { +} + +HDF5OutputParameter::HDF5OutputParameter(const HDF5OutputParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.HDF5OutputParameter) +} + +void HDF5OutputParameter::SharedCtor() { + _cached_size_ = 0; + file_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +HDF5OutputParameter::~HDF5OutputParameter() { + // @@protoc_insertion_point(destructor:caffe.HDF5OutputParameter) + SharedDtor(); +} + +void HDF5OutputParameter::SharedDtor() { + file_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void HDF5OutputParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* HDF5OutputParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return HDF5OutputParameter_descriptor_; +} + +const HDF5OutputParameter& HDF5OutputParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed HDF5OutputParameter_default_instance_; + +HDF5OutputParameter* HDF5OutputParameter::New(::google::protobuf::Arena* arena) const { + HDF5OutputParameter* n = new HDF5OutputParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void HDF5OutputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.HDF5OutputParameter) + if (has_file_name()) { + file_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool HDF5OutputParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.HDF5OutputParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string file_name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->file_name().data(), this->file_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.HDF5OutputParameter.file_name"); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.HDF5OutputParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.HDF5OutputParameter) + return false; +#undef DO_ +} + +void HDF5OutputParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.HDF5OutputParameter) + // optional string file_name = 1; + if (has_file_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->file_name().data(), this->file_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.HDF5OutputParameter.file_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->file_name(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.HDF5OutputParameter) +} + +::google::protobuf::uint8* HDF5OutputParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.HDF5OutputParameter) + // optional string file_name = 1; + if (has_file_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->file_name().data(), this->file_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.HDF5OutputParameter.file_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_name(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.HDF5OutputParameter) + return target; +} + +size_t HDF5OutputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.HDF5OutputParameter) + size_t total_size = 0; + + // optional string file_name = 1; + if (has_file_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_name()); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void HDF5OutputParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.HDF5OutputParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const HDF5OutputParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.HDF5OutputParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.HDF5OutputParameter) + UnsafeMergeFrom(*source); + } +} + +void HDF5OutputParameter::MergeFrom(const HDF5OutputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.HDF5OutputParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void HDF5OutputParameter::UnsafeMergeFrom(const HDF5OutputParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_name()) { + set_has_file_name(); + file_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.file_name_); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void HDF5OutputParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.HDF5OutputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HDF5OutputParameter::CopyFrom(const HDF5OutputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.HDF5OutputParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool HDF5OutputParameter::IsInitialized() const { + + return true; +} + +void HDF5OutputParameter::Swap(HDF5OutputParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void HDF5OutputParameter::InternalSwap(HDF5OutputParameter* other) { + file_name_.Swap(&other->file_name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata HDF5OutputParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = HDF5OutputParameter_descriptor_; + metadata.reflection = HDF5OutputParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// HDF5OutputParameter + +// optional string file_name = 1; +bool HDF5OutputParameter::has_file_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void HDF5OutputParameter::set_has_file_name() { + _has_bits_[0] |= 0x00000001u; +} +void HDF5OutputParameter::clear_has_file_name() { + _has_bits_[0] &= ~0x00000001u; +} +void HDF5OutputParameter::clear_file_name() { + file_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_file_name(); +} +const ::std::string& HDF5OutputParameter::file_name() const { + // @@protoc_insertion_point(field_get:caffe.HDF5OutputParameter.file_name) + return file_name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void HDF5OutputParameter::set_file_name(const ::std::string& value) { + set_has_file_name(); + file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.HDF5OutputParameter.file_name) +} +void HDF5OutputParameter::set_file_name(const char* value) { + set_has_file_name(); + file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.HDF5OutputParameter.file_name) +} +void HDF5OutputParameter::set_file_name(const char* value, size_t size) { + set_has_file_name(); + file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.HDF5OutputParameter.file_name) +} +::std::string* HDF5OutputParameter::mutable_file_name() { + set_has_file_name(); + // @@protoc_insertion_point(field_mutable:caffe.HDF5OutputParameter.file_name) + return file_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* HDF5OutputParameter::release_file_name() { + // @@protoc_insertion_point(field_release:caffe.HDF5OutputParameter.file_name) + clear_has_file_name(); + return file_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void HDF5OutputParameter::set_allocated_file_name(::std::string* file_name) { + if (file_name != NULL) { + set_has_file_name(); + } else { + clear_has_file_name(); + } + file_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), file_name); + // @@protoc_insertion_point(field_set_allocated:caffe.HDF5OutputParameter.file_name) +} + +inline const HDF5OutputParameter* HDF5OutputParameter::internal_default_instance() { + return &HDF5OutputParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* HingeLossParameter_Norm_descriptor() { + protobuf_AssignDescriptorsOnce(); + return HingeLossParameter_Norm_descriptor_; +} +bool HingeLossParameter_Norm_IsValid(int value) { + switch (value) { + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const HingeLossParameter_Norm HingeLossParameter::L1; +const HingeLossParameter_Norm HingeLossParameter::L2; +const HingeLossParameter_Norm HingeLossParameter::Norm_MIN; +const HingeLossParameter_Norm HingeLossParameter::Norm_MAX; +const int HingeLossParameter::Norm_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int HingeLossParameter::kNormFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +HingeLossParameter::HingeLossParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.HingeLossParameter) +} + +void HingeLossParameter::InitAsDefaultInstance() { +} + +HingeLossParameter::HingeLossParameter(const HingeLossParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.HingeLossParameter) +} + +void HingeLossParameter::SharedCtor() { + _cached_size_ = 0; + norm_ = 1; +} + +HingeLossParameter::~HingeLossParameter() { + // @@protoc_insertion_point(destructor:caffe.HingeLossParameter) + SharedDtor(); +} + +void HingeLossParameter::SharedDtor() { +} + +void HingeLossParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* HingeLossParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return HingeLossParameter_descriptor_; +} + +const HingeLossParameter& HingeLossParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed HingeLossParameter_default_instance_; + +HingeLossParameter* HingeLossParameter::New(::google::protobuf::Arena* arena) const { + HingeLossParameter* n = new HingeLossParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void HingeLossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.HingeLossParameter) + norm_ = 1; + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool HingeLossParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.HingeLossParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::HingeLossParameter_Norm_IsValid(value)) { + set_norm(static_cast< ::caffe::HingeLossParameter_Norm >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.HingeLossParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.HingeLossParameter) + return false; +#undef DO_ +} + +void HingeLossParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.HingeLossParameter) + // optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + if (has_norm()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->norm(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.HingeLossParameter) +} + +::google::protobuf::uint8* HingeLossParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.HingeLossParameter) + // optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + if (has_norm()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->norm(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.HingeLossParameter) + return target; +} + +size_t HingeLossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.HingeLossParameter) + size_t total_size = 0; + + // optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + if (has_norm()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->norm()); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void HingeLossParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.HingeLossParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const HingeLossParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.HingeLossParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.HingeLossParameter) + UnsafeMergeFrom(*source); + } +} + +void HingeLossParameter::MergeFrom(const HingeLossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.HingeLossParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void HingeLossParameter::UnsafeMergeFrom(const HingeLossParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_norm()) { + set_norm(from.norm()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void HingeLossParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.HingeLossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HingeLossParameter::CopyFrom(const HingeLossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.HingeLossParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool HingeLossParameter::IsInitialized() const { + + return true; +} + +void HingeLossParameter::Swap(HingeLossParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void HingeLossParameter::InternalSwap(HingeLossParameter* other) { + std::swap(norm_, other->norm_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata HingeLossParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = HingeLossParameter_descriptor_; + metadata.reflection = HingeLossParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// HingeLossParameter + +// optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1]; +bool HingeLossParameter::has_norm() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void HingeLossParameter::set_has_norm() { + _has_bits_[0] |= 0x00000001u; +} +void HingeLossParameter::clear_has_norm() { + _has_bits_[0] &= ~0x00000001u; +} +void HingeLossParameter::clear_norm() { + norm_ = 1; + clear_has_norm(); +} +::caffe::HingeLossParameter_Norm HingeLossParameter::norm() const { + // @@protoc_insertion_point(field_get:caffe.HingeLossParameter.norm) + return static_cast< ::caffe::HingeLossParameter_Norm >(norm_); +} +void HingeLossParameter::set_norm(::caffe::HingeLossParameter_Norm value) { + assert(::caffe::HingeLossParameter_Norm_IsValid(value)); + set_has_norm(); + norm_ = value; + // @@protoc_insertion_point(field_set:caffe.HingeLossParameter.norm) +} + +inline const HingeLossParameter* HingeLossParameter::internal_default_instance() { + return &HingeLossParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ImageDataParameter::kSourceFieldNumber; +const int ImageDataParameter::kBatchSizeFieldNumber; +const int ImageDataParameter::kRandSkipFieldNumber; +const int ImageDataParameter::kShuffleFieldNumber; +const int ImageDataParameter::kNewHeightFieldNumber; +const int ImageDataParameter::kNewWidthFieldNumber; +const int ImageDataParameter::kIsColorFieldNumber; +const int ImageDataParameter::kScaleFieldNumber; +const int ImageDataParameter::kMeanFileFieldNumber; +const int ImageDataParameter::kCropSizeFieldNumber; +const int ImageDataParameter::kMirrorFieldNumber; +const int ImageDataParameter::kRootFolderFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ImageDataParameter::ImageDataParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ImageDataParameter) +} + +void ImageDataParameter::InitAsDefaultInstance() { +} + +ImageDataParameter::ImageDataParameter(const ImageDataParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ImageDataParameter) +} + +void ImageDataParameter::SharedCtor() { + _cached_size_ = 0; + source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + root_folder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&rand_skip_, 0, reinterpret_cast(&crop_size_) - + reinterpret_cast(&rand_skip_) + sizeof(crop_size_)); + scale_ = 1; + batch_size_ = 1u; + is_color_ = true; +} + +ImageDataParameter::~ImageDataParameter() { + // @@protoc_insertion_point(destructor:caffe.ImageDataParameter) + SharedDtor(); +} + +void ImageDataParameter::SharedDtor() { + source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + root_folder_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void ImageDataParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ImageDataParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ImageDataParameter_descriptor_; +} + +const ImageDataParameter& ImageDataParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ImageDataParameter_default_instance_; + +ImageDataParameter* ImageDataParameter::New(::google::protobuf::Arena* arena) const { + ImageDataParameter* n = new ImageDataParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ImageDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ImageDataParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(ImageDataParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 255u) { + ZR_(rand_skip_, shuffle_); + if (has_source()) { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + batch_size_ = 1u; + is_color_ = true; + scale_ = 1; + } + if (_has_bits_[8 / 32] & 3840u) { + ZR_(mirror_, crop_size_); + if (has_mean_file()) { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_root_folder()) { + root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ImageDataParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ImageDataParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string source = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_source())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.ImageDataParameter.source"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_scale; + break; + } + + // optional float scale = 2 [default = 1]; + case 2: { + if (tag == 21) { + parse_scale: + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_mean_file; + break; + } + + // optional string mean_file = 3; + case 3: { + if (tag == 26) { + parse_mean_file: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_mean_file())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.ImageDataParameter.mean_file"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_batch_size; + break; + } + + // optional uint32 batch_size = 4 [default = 1]; + case 4: { + if (tag == 32) { + parse_batch_size: + set_has_batch_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &batch_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_crop_size; + break; + } + + // optional uint32 crop_size = 5 [default = 0]; + case 5: { + if (tag == 40) { + parse_crop_size: + set_has_crop_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &crop_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_mirror; + break; + } + + // optional bool mirror = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_mirror: + set_has_mirror(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &mirror_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_rand_skip; + break; + } + + // optional uint32 rand_skip = 7 [default = 0]; + case 7: { + if (tag == 56) { + parse_rand_skip: + set_has_rand_skip(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &rand_skip_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_shuffle; + break; + } + + // optional bool shuffle = 8 [default = false]; + case 8: { + if (tag == 64) { + parse_shuffle: + set_has_shuffle(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &shuffle_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_new_height; + break; + } + + // optional uint32 new_height = 9 [default = 0]; + case 9: { + if (tag == 72) { + parse_new_height: + set_has_new_height(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &new_height_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_new_width; + break; + } + + // optional uint32 new_width = 10 [default = 0]; + case 10: { + if (tag == 80) { + parse_new_width: + set_has_new_width(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &new_width_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_is_color; + break; + } + + // optional bool is_color = 11 [default = true]; + case 11: { + if (tag == 88) { + parse_is_color: + set_has_is_color(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_color_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(98)) goto parse_root_folder; + break; + } + + // optional string root_folder = 12 [default = ""]; + case 12: { + if (tag == 98) { + parse_root_folder: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_root_folder())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->root_folder().data(), this->root_folder().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.ImageDataParameter.root_folder"); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ImageDataParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ImageDataParameter) + return false; +#undef DO_ +} + +void ImageDataParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ImageDataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ImageDataParameter.source"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->source(), output); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output); + } + + // optional string mean_file = 3; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ImageDataParameter.mean_file"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->mean_file(), output); + } + + // optional uint32 batch_size = 4 [default = 1]; + if (has_batch_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->batch_size(), output); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->crop_size(), output); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->mirror(), output); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (has_rand_skip()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->rand_skip(), output); + } + + // optional bool shuffle = 8 [default = false]; + if (has_shuffle()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->shuffle(), output); + } + + // optional uint32 new_height = 9 [default = 0]; + if (has_new_height()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->new_height(), output); + } + + // optional uint32 new_width = 10 [default = 0]; + if (has_new_width()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->new_width(), output); + } + + // optional bool is_color = 11 [default = true]; + if (has_is_color()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->is_color(), output); + } + + // optional string root_folder = 12 [default = ""]; + if (has_root_folder()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->root_folder().data(), this->root_folder().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ImageDataParameter.root_folder"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 12, this->root_folder(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ImageDataParameter) +} + +::google::protobuf::uint8* ImageDataParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ImageDataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ImageDataParameter.source"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->source(), target); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target); + } + + // optional string mean_file = 3; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ImageDataParameter.mean_file"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->mean_file(), target); + } + + // optional uint32 batch_size = 4 [default = 1]; + if (has_batch_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->batch_size(), target); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->crop_size(), target); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->mirror(), target); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (has_rand_skip()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->rand_skip(), target); + } + + // optional bool shuffle = 8 [default = false]; + if (has_shuffle()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->shuffle(), target); + } + + // optional uint32 new_height = 9 [default = 0]; + if (has_new_height()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->new_height(), target); + } + + // optional uint32 new_width = 10 [default = 0]; + if (has_new_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->new_width(), target); + } + + // optional bool is_color = 11 [default = true]; + if (has_is_color()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->is_color(), target); + } + + // optional string root_folder = 12 [default = ""]; + if (has_root_folder()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->root_folder().data(), this->root_folder().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.ImageDataParameter.root_folder"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 12, this->root_folder(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ImageDataParameter) + return target; +} + +size_t ImageDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ImageDataParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional string source = 1; + if (has_source()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->source()); + } + + // optional uint32 batch_size = 4 [default = 1]; + if (has_batch_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->batch_size()); + } + + // optional uint32 rand_skip = 7 [default = 0]; + if (has_rand_skip()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->rand_skip()); + } + + // optional bool shuffle = 8 [default = false]; + if (has_shuffle()) { + total_size += 1 + 1; + } + + // optional uint32 new_height = 9 [default = 0]; + if (has_new_height()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->new_height()); + } + + // optional uint32 new_width = 10 [default = 0]; + if (has_new_width()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->new_width()); + } + + // optional bool is_color = 11 [default = true]; + if (has_is_color()) { + total_size += 1 + 1; + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + total_size += 1 + 4; + } + + } + if (_has_bits_[8 / 32] & 3840u) { + // optional string mean_file = 3; + if (has_mean_file()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->mean_file()); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->crop_size()); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + total_size += 1 + 1; + } + + // optional string root_folder = 12 [default = ""]; + if (has_root_folder()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->root_folder()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ImageDataParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ImageDataParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ImageDataParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ImageDataParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ImageDataParameter) + UnsafeMergeFrom(*source); + } +} + +void ImageDataParameter::MergeFrom(const ImageDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ImageDataParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ImageDataParameter::UnsafeMergeFrom(const ImageDataParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_source()) { + set_has_source(); + source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_); + } + if (from.has_batch_size()) { + set_batch_size(from.batch_size()); + } + if (from.has_rand_skip()) { + set_rand_skip(from.rand_skip()); + } + if (from.has_shuffle()) { + set_shuffle(from.shuffle()); + } + if (from.has_new_height()) { + set_new_height(from.new_height()); + } + if (from.has_new_width()) { + set_new_width(from.new_width()); + } + if (from.has_is_color()) { + set_is_color(from.is_color()); + } + if (from.has_scale()) { + set_scale(from.scale()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_mean_file()) { + set_has_mean_file(); + mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_); + } + if (from.has_crop_size()) { + set_crop_size(from.crop_size()); + } + if (from.has_mirror()) { + set_mirror(from.mirror()); + } + if (from.has_root_folder()) { + set_has_root_folder(); + root_folder_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.root_folder_); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ImageDataParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ImageDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ImageDataParameter::CopyFrom(const ImageDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ImageDataParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ImageDataParameter::IsInitialized() const { + + return true; +} + +void ImageDataParameter::Swap(ImageDataParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ImageDataParameter::InternalSwap(ImageDataParameter* other) { + source_.Swap(&other->source_); + std::swap(batch_size_, other->batch_size_); + std::swap(rand_skip_, other->rand_skip_); + std::swap(shuffle_, other->shuffle_); + std::swap(new_height_, other->new_height_); + std::swap(new_width_, other->new_width_); + std::swap(is_color_, other->is_color_); + std::swap(scale_, other->scale_); + mean_file_.Swap(&other->mean_file_); + std::swap(crop_size_, other->crop_size_); + std::swap(mirror_, other->mirror_); + root_folder_.Swap(&other->root_folder_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ImageDataParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ImageDataParameter_descriptor_; + metadata.reflection = ImageDataParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ImageDataParameter + +// optional string source = 1; +bool ImageDataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ImageDataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +void ImageDataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +void ImageDataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +const ::std::string& ImageDataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ImageDataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.source) +} +void ImageDataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ImageDataParameter.source) +} +void ImageDataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ImageDataParameter.source) +} +::std::string* ImageDataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* ImageDataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.ImageDataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ImageDataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.source) +} + +// optional uint32 batch_size = 4 [default = 1]; +bool ImageDataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ImageDataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000002u; +} +void ImageDataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000002u; +} +void ImageDataParameter::clear_batch_size() { + batch_size_ = 1u; + clear_has_batch_size(); +} +::google::protobuf::uint32 ImageDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.batch_size) + return batch_size_; +} +void ImageDataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.batch_size) +} + +// optional uint32 rand_skip = 7 [default = 0]; +bool ImageDataParameter::has_rand_skip() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void ImageDataParameter::set_has_rand_skip() { + _has_bits_[0] |= 0x00000004u; +} +void ImageDataParameter::clear_has_rand_skip() { + _has_bits_[0] &= ~0x00000004u; +} +void ImageDataParameter::clear_rand_skip() { + rand_skip_ = 0u; + clear_has_rand_skip(); +} +::google::protobuf::uint32 ImageDataParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.rand_skip) + return rand_skip_; +} +void ImageDataParameter::set_rand_skip(::google::protobuf::uint32 value) { + set_has_rand_skip(); + rand_skip_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.rand_skip) +} + +// optional bool shuffle = 8 [default = false]; +bool ImageDataParameter::has_shuffle() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void ImageDataParameter::set_has_shuffle() { + _has_bits_[0] |= 0x00000008u; +} +void ImageDataParameter::clear_has_shuffle() { + _has_bits_[0] &= ~0x00000008u; +} +void ImageDataParameter::clear_shuffle() { + shuffle_ = false; + clear_has_shuffle(); +} +bool ImageDataParameter::shuffle() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.shuffle) + return shuffle_; +} +void ImageDataParameter::set_shuffle(bool value) { + set_has_shuffle(); + shuffle_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.shuffle) +} + +// optional uint32 new_height = 9 [default = 0]; +bool ImageDataParameter::has_new_height() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void ImageDataParameter::set_has_new_height() { + _has_bits_[0] |= 0x00000010u; +} +void ImageDataParameter::clear_has_new_height() { + _has_bits_[0] &= ~0x00000010u; +} +void ImageDataParameter::clear_new_height() { + new_height_ = 0u; + clear_has_new_height(); +} +::google::protobuf::uint32 ImageDataParameter::new_height() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.new_height) + return new_height_; +} +void ImageDataParameter::set_new_height(::google::protobuf::uint32 value) { + set_has_new_height(); + new_height_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.new_height) +} + +// optional uint32 new_width = 10 [default = 0]; +bool ImageDataParameter::has_new_width() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void ImageDataParameter::set_has_new_width() { + _has_bits_[0] |= 0x00000020u; +} +void ImageDataParameter::clear_has_new_width() { + _has_bits_[0] &= ~0x00000020u; +} +void ImageDataParameter::clear_new_width() { + new_width_ = 0u; + clear_has_new_width(); +} +::google::protobuf::uint32 ImageDataParameter::new_width() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.new_width) + return new_width_; +} +void ImageDataParameter::set_new_width(::google::protobuf::uint32 value) { + set_has_new_width(); + new_width_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.new_width) +} + +// optional bool is_color = 11 [default = true]; +bool ImageDataParameter::has_is_color() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void ImageDataParameter::set_has_is_color() { + _has_bits_[0] |= 0x00000040u; +} +void ImageDataParameter::clear_has_is_color() { + _has_bits_[0] &= ~0x00000040u; +} +void ImageDataParameter::clear_is_color() { + is_color_ = true; + clear_has_is_color(); +} +bool ImageDataParameter::is_color() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.is_color) + return is_color_; +} +void ImageDataParameter::set_is_color(bool value) { + set_has_is_color(); + is_color_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.is_color) +} + +// optional float scale = 2 [default = 1]; +bool ImageDataParameter::has_scale() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void ImageDataParameter::set_has_scale() { + _has_bits_[0] |= 0x00000080u; +} +void ImageDataParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000080u; +} +void ImageDataParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float ImageDataParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.scale) + return scale_; +} +void ImageDataParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.scale) +} + +// optional string mean_file = 3; +bool ImageDataParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void ImageDataParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000100u; +} +void ImageDataParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000100u; +} +void ImageDataParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +const ::std::string& ImageDataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ImageDataParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.mean_file) +} +void ImageDataParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ImageDataParameter.mean_file) +} +void ImageDataParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ImageDataParameter.mean_file) +} +::std::string* ImageDataParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* ImageDataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.ImageDataParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ImageDataParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.mean_file) +} + +// optional uint32 crop_size = 5 [default = 0]; +bool ImageDataParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void ImageDataParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000200u; +} +void ImageDataParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000200u; +} +void ImageDataParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +::google::protobuf::uint32 ImageDataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.crop_size) + return crop_size_; +} +void ImageDataParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +bool ImageDataParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +void ImageDataParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000400u; +} +void ImageDataParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000400u; +} +void ImageDataParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +bool ImageDataParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.mirror) + return mirror_; +} +void ImageDataParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.mirror) +} + +// optional string root_folder = 12 [default = ""]; +bool ImageDataParameter::has_root_folder() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void ImageDataParameter::set_has_root_folder() { + _has_bits_[0] |= 0x00000800u; +} +void ImageDataParameter::clear_has_root_folder() { + _has_bits_[0] &= ~0x00000800u; +} +void ImageDataParameter::clear_root_folder() { + root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_root_folder(); +} +const ::std::string& ImageDataParameter::root_folder() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.root_folder) + return root_folder_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ImageDataParameter::set_root_folder(const ::std::string& value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.root_folder) +} +void ImageDataParameter::set_root_folder(const char* value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ImageDataParameter.root_folder) +} +void ImageDataParameter::set_root_folder(const char* value, size_t size) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ImageDataParameter.root_folder) +} +::std::string* ImageDataParameter::mutable_root_folder() { + set_has_root_folder(); + // @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.root_folder) + return root_folder_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* ImageDataParameter::release_root_folder() { + // @@protoc_insertion_point(field_release:caffe.ImageDataParameter.root_folder) + clear_has_root_folder(); + return root_folder_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void ImageDataParameter::set_allocated_root_folder(::std::string* root_folder) { + if (root_folder != NULL) { + set_has_root_folder(); + } else { + clear_has_root_folder(); + } + root_folder_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root_folder); + // @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.root_folder) +} + +inline const ImageDataParameter* ImageDataParameter::internal_default_instance() { + return &ImageDataParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int InfogainLossParameter::kSourceFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +InfogainLossParameter::InfogainLossParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.InfogainLossParameter) +} + +void InfogainLossParameter::InitAsDefaultInstance() { +} + +InfogainLossParameter::InfogainLossParameter(const InfogainLossParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.InfogainLossParameter) +} + +void InfogainLossParameter::SharedCtor() { + _cached_size_ = 0; + source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +InfogainLossParameter::~InfogainLossParameter() { + // @@protoc_insertion_point(destructor:caffe.InfogainLossParameter) + SharedDtor(); +} + +void InfogainLossParameter::SharedDtor() { + source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void InfogainLossParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InfogainLossParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InfogainLossParameter_descriptor_; +} + +const InfogainLossParameter& InfogainLossParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed InfogainLossParameter_default_instance_; + +InfogainLossParameter* InfogainLossParameter::New(::google::protobuf::Arena* arena) const { + InfogainLossParameter* n = new InfogainLossParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void InfogainLossParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.InfogainLossParameter) + if (has_source()) { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool InfogainLossParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.InfogainLossParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string source = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_source())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.InfogainLossParameter.source"); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.InfogainLossParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.InfogainLossParameter) + return false; +#undef DO_ +} + +void InfogainLossParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.InfogainLossParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.InfogainLossParameter.source"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->source(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.InfogainLossParameter) +} + +::google::protobuf::uint8* InfogainLossParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.InfogainLossParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.InfogainLossParameter.source"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->source(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.InfogainLossParameter) + return target; +} + +size_t InfogainLossParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.InfogainLossParameter) + size_t total_size = 0; + + // optional string source = 1; + if (has_source()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->source()); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void InfogainLossParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.InfogainLossParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const InfogainLossParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.InfogainLossParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.InfogainLossParameter) + UnsafeMergeFrom(*source); + } +} + +void InfogainLossParameter::MergeFrom(const InfogainLossParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.InfogainLossParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void InfogainLossParameter::UnsafeMergeFrom(const InfogainLossParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_source()) { + set_has_source(); + source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void InfogainLossParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.InfogainLossParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InfogainLossParameter::CopyFrom(const InfogainLossParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.InfogainLossParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool InfogainLossParameter::IsInitialized() const { + + return true; +} + +void InfogainLossParameter::Swap(InfogainLossParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void InfogainLossParameter::InternalSwap(InfogainLossParameter* other) { + source_.Swap(&other->source_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata InfogainLossParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InfogainLossParameter_descriptor_; + metadata.reflection = InfogainLossParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// InfogainLossParameter + +// optional string source = 1; +bool InfogainLossParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void InfogainLossParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +void InfogainLossParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +void InfogainLossParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +const ::std::string& InfogainLossParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.InfogainLossParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void InfogainLossParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.InfogainLossParameter.source) +} +void InfogainLossParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.InfogainLossParameter.source) +} +void InfogainLossParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.InfogainLossParameter.source) +} +::std::string* InfogainLossParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.InfogainLossParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* InfogainLossParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.InfogainLossParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void InfogainLossParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.InfogainLossParameter.source) +} + +inline const InfogainLossParameter* InfogainLossParameter::internal_default_instance() { + return &InfogainLossParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int InnerProductParameter::kNumOutputFieldNumber; +const int InnerProductParameter::kBiasTermFieldNumber; +const int InnerProductParameter::kWeightFillerFieldNumber; +const int InnerProductParameter::kBiasFillerFieldNumber; +const int InnerProductParameter::kAxisFieldNumber; +const int InnerProductParameter::kTransposeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +InnerProductParameter::InnerProductParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.InnerProductParameter) +} + +void InnerProductParameter::InitAsDefaultInstance() { + weight_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); + bias_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +InnerProductParameter::InnerProductParameter(const InnerProductParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.InnerProductParameter) +} + +void InnerProductParameter::SharedCtor() { + _cached_size_ = 0; + weight_filler_ = NULL; + bias_filler_ = NULL; + ::memset(&num_output_, 0, reinterpret_cast(&transpose_) - + reinterpret_cast(&num_output_) + sizeof(transpose_)); + bias_term_ = true; + axis_ = 1; +} + +InnerProductParameter::~InnerProductParameter() { + // @@protoc_insertion_point(destructor:caffe.InnerProductParameter) + SharedDtor(); +} + +void InnerProductParameter::SharedDtor() { + if (this != &InnerProductParameter_default_instance_.get()) { + delete weight_filler_; + delete bias_filler_; + } +} + +void InnerProductParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InnerProductParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InnerProductParameter_descriptor_; +} + +const InnerProductParameter& InnerProductParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed InnerProductParameter_default_instance_; + +InnerProductParameter* InnerProductParameter::New(::google::protobuf::Arena* arena) const { + InnerProductParameter* n = new InnerProductParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void InnerProductParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.InnerProductParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(InnerProductParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 63u) { + ZR_(num_output_, transpose_); + bias_term_ = true; + if (has_weight_filler()) { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + } + if (has_bias_filler()) { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + } + axis_ = 1; + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool InnerProductParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.InnerProductParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 num_output = 1; + case 1: { + if (tag == 8) { + set_has_num_output(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &num_output_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_bias_term; + break; + } + + // optional bool bias_term = 2 [default = true]; + case 2: { + if (tag == 16) { + parse_bias_term: + set_has_bias_term(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &bias_term_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_weight_filler; + break; + } + + // optional .caffe.FillerParameter weight_filler = 3; + case 3: { + if (tag == 26) { + parse_weight_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_weight_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_bias_filler; + break; + } + + // optional .caffe.FillerParameter bias_filler = 4; + case 4: { + if (tag == 34) { + parse_bias_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bias_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_axis; + break; + } + + // optional int32 axis = 5 [default = 1]; + case 5: { + if (tag == 40) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_transpose; + break; + } + + // optional bool transpose = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_transpose: + set_has_transpose(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &transpose_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.InnerProductParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.InnerProductParameter) + return false; +#undef DO_ +} + +void InnerProductParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.InnerProductParameter) + // optional uint32 num_output = 1; + if (has_num_output()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output); + } + + // optional bool bias_term = 2 [default = true]; + if (has_bias_term()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->bias_term(), output); + } + + // optional .caffe.FillerParameter weight_filler = 3; + if (has_weight_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, *this->weight_filler_, output); + } + + // optional .caffe.FillerParameter bias_filler = 4; + if (has_bias_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, *this->bias_filler_, output); + } + + // optional int32 axis = 5 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->axis(), output); + } + + // optional bool transpose = 6 [default = false]; + if (has_transpose()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->transpose(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.InnerProductParameter) +} + +::google::protobuf::uint8* InnerProductParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.InnerProductParameter) + // optional uint32 num_output = 1; + if (has_num_output()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target); + } + + // optional bool bias_term = 2 [default = true]; + if (has_bias_term()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->bias_term(), target); + } + + // optional .caffe.FillerParameter weight_filler = 3; + if (has_weight_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 3, *this->weight_filler_, false, target); + } + + // optional .caffe.FillerParameter bias_filler = 4; + if (has_bias_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 4, *this->bias_filler_, false, target); + } + + // optional int32 axis = 5 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->axis(), target); + } + + // optional bool transpose = 6 [default = false]; + if (has_transpose()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->transpose(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.InnerProductParameter) + return target; +} + +size_t InnerProductParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.InnerProductParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 63u) { + // optional uint32 num_output = 1; + if (has_num_output()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->num_output()); + } + + // optional bool bias_term = 2 [default = true]; + if (has_bias_term()) { + total_size += 1 + 1; + } + + // optional .caffe.FillerParameter weight_filler = 3; + if (has_weight_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->weight_filler_); + } + + // optional .caffe.FillerParameter bias_filler = 4; + if (has_bias_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->bias_filler_); + } + + // optional int32 axis = 5 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional bool transpose = 6 [default = false]; + if (has_transpose()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void InnerProductParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.InnerProductParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const InnerProductParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.InnerProductParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.InnerProductParameter) + UnsafeMergeFrom(*source); + } +} + +void InnerProductParameter::MergeFrom(const InnerProductParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.InnerProductParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void InnerProductParameter::UnsafeMergeFrom(const InnerProductParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_num_output()) { + set_num_output(from.num_output()); + } + if (from.has_bias_term()) { + set_bias_term(from.bias_term()); + } + if (from.has_weight_filler()) { + mutable_weight_filler()->::caffe::FillerParameter::MergeFrom(from.weight_filler()); + } + if (from.has_bias_filler()) { + mutable_bias_filler()->::caffe::FillerParameter::MergeFrom(from.bias_filler()); + } + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_transpose()) { + set_transpose(from.transpose()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void InnerProductParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.InnerProductParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InnerProductParameter::CopyFrom(const InnerProductParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.InnerProductParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool InnerProductParameter::IsInitialized() const { + + return true; +} + +void InnerProductParameter::Swap(InnerProductParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void InnerProductParameter::InternalSwap(InnerProductParameter* other) { + std::swap(num_output_, other->num_output_); + std::swap(bias_term_, other->bias_term_); + std::swap(weight_filler_, other->weight_filler_); + std::swap(bias_filler_, other->bias_filler_); + std::swap(axis_, other->axis_); + std::swap(transpose_, other->transpose_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata InnerProductParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InnerProductParameter_descriptor_; + metadata.reflection = InnerProductParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// InnerProductParameter + +// optional uint32 num_output = 1; +bool InnerProductParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void InnerProductParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +void InnerProductParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +void InnerProductParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +::google::protobuf::uint32 InnerProductParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.num_output) + return num_output_; +} +void InnerProductParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.num_output) +} + +// optional bool bias_term = 2 [default = true]; +bool InnerProductParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void InnerProductParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000002u; +} +void InnerProductParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000002u; +} +void InnerProductParameter::clear_bias_term() { + bias_term_ = true; + clear_has_bias_term(); +} +bool InnerProductParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.bias_term) + return bias_term_; +} +void InnerProductParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.bias_term) +} + +// optional .caffe.FillerParameter weight_filler = 3; +bool InnerProductParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void InnerProductParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000004u; +} +void InnerProductParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000004u; +} +void InnerProductParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +const ::caffe::FillerParameter& InnerProductParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* InnerProductParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.InnerProductParameter.weight_filler) + return weight_filler_; +} +::caffe::FillerParameter* InnerProductParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.InnerProductParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +void InnerProductParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.InnerProductParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 4; +bool InnerProductParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void InnerProductParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000008u; +} +void InnerProductParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000008u; +} +void InnerProductParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +const ::caffe::FillerParameter& InnerProductParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* InnerProductParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.InnerProductParameter.bias_filler) + return bias_filler_; +} +::caffe::FillerParameter* InnerProductParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.InnerProductParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +void InnerProductParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.InnerProductParameter.bias_filler) +} + +// optional int32 axis = 5 [default = 1]; +bool InnerProductParameter::has_axis() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void InnerProductParameter::set_has_axis() { + _has_bits_[0] |= 0x00000010u; +} +void InnerProductParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000010u; +} +void InnerProductParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 InnerProductParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.axis) + return axis_; +} +void InnerProductParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.axis) +} + +// optional bool transpose = 6 [default = false]; +bool InnerProductParameter::has_transpose() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void InnerProductParameter::set_has_transpose() { + _has_bits_[0] |= 0x00000020u; +} +void InnerProductParameter::clear_has_transpose() { + _has_bits_[0] &= ~0x00000020u; +} +void InnerProductParameter::clear_transpose() { + transpose_ = false; + clear_has_transpose(); +} +bool InnerProductParameter::transpose() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.transpose) + return transpose_; +} +void InnerProductParameter::set_transpose(bool value) { + set_has_transpose(); + transpose_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.transpose) +} + +inline const InnerProductParameter* InnerProductParameter::internal_default_instance() { + return &InnerProductParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int InputParameter::kShapeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +InputParameter::InputParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.InputParameter) +} + +void InputParameter::InitAsDefaultInstance() { +} + +InputParameter::InputParameter(const InputParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.InputParameter) +} + +void InputParameter::SharedCtor() { + _cached_size_ = 0; +} + +InputParameter::~InputParameter() { + // @@protoc_insertion_point(destructor:caffe.InputParameter) + SharedDtor(); +} + +void InputParameter::SharedDtor() { +} + +void InputParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InputParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InputParameter_descriptor_; +} + +const InputParameter& InputParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed InputParameter_default_instance_; + +InputParameter* InputParameter::New(::google::protobuf::Arena* arena) const { + InputParameter* n = new InputParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void InputParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.InputParameter) + shape_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool InputParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.InputParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .caffe.BlobShape shape = 1; + case 1: { + if (tag == 10) { + DO_(input->IncrementRecursionDepth()); + parse_loop_shape: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_loop_shape; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.InputParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.InputParameter) + return false; +#undef DO_ +} + +void InputParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.InputParameter) + // repeated .caffe.BlobShape shape = 1; + for (unsigned int i = 0, n = this->shape_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->shape(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.InputParameter) +} + +::google::protobuf::uint8* InputParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.InputParameter) + // repeated .caffe.BlobShape shape = 1; + for (unsigned int i = 0, n = this->shape_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, this->shape(i), false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.InputParameter) + return target; +} + +size_t InputParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.InputParameter) + size_t total_size = 0; + + // repeated .caffe.BlobShape shape = 1; + { + unsigned int count = this->shape_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->shape(i)); + } + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void InputParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.InputParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const InputParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.InputParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.InputParameter) + UnsafeMergeFrom(*source); + } +} + +void InputParameter::MergeFrom(const InputParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.InputParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void InputParameter::UnsafeMergeFrom(const InputParameter& from) { + GOOGLE_DCHECK(&from != this); + shape_.MergeFrom(from.shape_); + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void InputParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.InputParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InputParameter::CopyFrom(const InputParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.InputParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool InputParameter::IsInitialized() const { + + return true; +} + +void InputParameter::Swap(InputParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void InputParameter::InternalSwap(InputParameter* other) { + shape_.UnsafeArenaSwap(&other->shape_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata InputParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InputParameter_descriptor_; + metadata.reflection = InputParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// InputParameter + +// repeated .caffe.BlobShape shape = 1; +int InputParameter::shape_size() const { + return shape_.size(); +} +void InputParameter::clear_shape() { + shape_.Clear(); +} +const ::caffe::BlobShape& InputParameter::shape(int index) const { + // @@protoc_insertion_point(field_get:caffe.InputParameter.shape) + return shape_.Get(index); +} +::caffe::BlobShape* InputParameter::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:caffe.InputParameter.shape) + return shape_.Mutable(index); +} +::caffe::BlobShape* InputParameter::add_shape() { + // @@protoc_insertion_point(field_add:caffe.InputParameter.shape) + return shape_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* +InputParameter::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:caffe.InputParameter.shape) + return &shape_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& +InputParameter::shape() const { + // @@protoc_insertion_point(field_list:caffe.InputParameter.shape) + return shape_; +} + +inline const InputParameter* InputParameter::internal_default_instance() { + return &InputParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int LogParameter::kBaseFieldNumber; +const int LogParameter::kScaleFieldNumber; +const int LogParameter::kShiftFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +LogParameter::LogParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.LogParameter) +} + +void LogParameter::InitAsDefaultInstance() { +} + +LogParameter::LogParameter(const LogParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.LogParameter) +} + +void LogParameter::SharedCtor() { + _cached_size_ = 0; + shift_ = 0; + base_ = -1; + scale_ = 1; +} + +LogParameter::~LogParameter() { + // @@protoc_insertion_point(destructor:caffe.LogParameter) + SharedDtor(); +} + +void LogParameter::SharedDtor() { +} + +void LogParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LogParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LogParameter_descriptor_; +} + +const LogParameter& LogParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed LogParameter_default_instance_; + +LogParameter* LogParameter::New(::google::protobuf::Arena* arena) const { + LogParameter* n = new LogParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void LogParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.LogParameter) + if (_has_bits_[0 / 32] & 7u) { + base_ = -1; + scale_ = 1; + shift_ = 0; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool LogParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.LogParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float base = 1 [default = -1]; + case 1: { + if (tag == 13) { + set_has_base(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &base_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_scale; + break; + } + + // optional float scale = 2 [default = 1]; + case 2: { + if (tag == 21) { + parse_scale: + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_shift; + break; + } + + // optional float shift = 3 [default = 0]; + case 3: { + if (tag == 29) { + parse_shift: + set_has_shift(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &shift_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.LogParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.LogParameter) + return false; +#undef DO_ +} + +void LogParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.LogParameter) + // optional float base = 1 [default = -1]; + if (has_base()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->base(), output); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output); + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->shift(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.LogParameter) +} + +::google::protobuf::uint8* LogParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.LogParameter) + // optional float base = 1 [default = -1]; + if (has_base()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->base(), target); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target); + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->shift(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.LogParameter) + return target; +} + +size_t LogParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.LogParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional float base = 1 [default = -1]; + if (has_base()) { + total_size += 1 + 4; + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + total_size += 1 + 4; + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void LogParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.LogParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const LogParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.LogParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.LogParameter) + UnsafeMergeFrom(*source); + } +} + +void LogParameter::MergeFrom(const LogParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.LogParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void LogParameter::UnsafeMergeFrom(const LogParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_base()) { + set_base(from.base()); + } + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_shift()) { + set_shift(from.shift()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void LogParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.LogParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LogParameter::CopyFrom(const LogParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.LogParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool LogParameter::IsInitialized() const { + + return true; +} + +void LogParameter::Swap(LogParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void LogParameter::InternalSwap(LogParameter* other) { + std::swap(base_, other->base_); + std::swap(scale_, other->scale_); + std::swap(shift_, other->shift_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata LogParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LogParameter_descriptor_; + metadata.reflection = LogParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// LogParameter + +// optional float base = 1 [default = -1]; +bool LogParameter::has_base() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void LogParameter::set_has_base() { + _has_bits_[0] |= 0x00000001u; +} +void LogParameter::clear_has_base() { + _has_bits_[0] &= ~0x00000001u; +} +void LogParameter::clear_base() { + base_ = -1; + clear_has_base(); +} +float LogParameter::base() const { + // @@protoc_insertion_point(field_get:caffe.LogParameter.base) + return base_; +} +void LogParameter::set_base(float value) { + set_has_base(); + base_ = value; + // @@protoc_insertion_point(field_set:caffe.LogParameter.base) +} + +// optional float scale = 2 [default = 1]; +bool LogParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void LogParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +void LogParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +void LogParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float LogParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.LogParameter.scale) + return scale_; +} +void LogParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.LogParameter.scale) +} + +// optional float shift = 3 [default = 0]; +bool LogParameter::has_shift() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void LogParameter::set_has_shift() { + _has_bits_[0] |= 0x00000004u; +} +void LogParameter::clear_has_shift() { + _has_bits_[0] &= ~0x00000004u; +} +void LogParameter::clear_shift() { + shift_ = 0; + clear_has_shift(); +} +float LogParameter::shift() const { + // @@protoc_insertion_point(field_get:caffe.LogParameter.shift) + return shift_; +} +void LogParameter::set_shift(float value) { + set_has_shift(); + shift_ = value; + // @@protoc_insertion_point(field_set:caffe.LogParameter.shift) +} + +inline const LogParameter* LogParameter::internal_default_instance() { + return &LogParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* LRNParameter_NormRegion_descriptor() { + protobuf_AssignDescriptorsOnce(); + return LRNParameter_NormRegion_descriptor_; +} +bool LRNParameter_NormRegion_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const LRNParameter_NormRegion LRNParameter::ACROSS_CHANNELS; +const LRNParameter_NormRegion LRNParameter::WITHIN_CHANNEL; +const LRNParameter_NormRegion LRNParameter::NormRegion_MIN; +const LRNParameter_NormRegion LRNParameter::NormRegion_MAX; +const int LRNParameter::NormRegion_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* LRNParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return LRNParameter_Engine_descriptor_; +} +bool LRNParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const LRNParameter_Engine LRNParameter::DEFAULT; +const LRNParameter_Engine LRNParameter::CAFFE; +const LRNParameter_Engine LRNParameter::CUDNN; +const LRNParameter_Engine LRNParameter::Engine_MIN; +const LRNParameter_Engine LRNParameter::Engine_MAX; +const int LRNParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int LRNParameter::kLocalSizeFieldNumber; +const int LRNParameter::kAlphaFieldNumber; +const int LRNParameter::kBetaFieldNumber; +const int LRNParameter::kNormRegionFieldNumber; +const int LRNParameter::kKFieldNumber; +const int LRNParameter::kEngineFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +LRNParameter::LRNParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.LRNParameter) +} + +void LRNParameter::InitAsDefaultInstance() { +} + +LRNParameter::LRNParameter(const LRNParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.LRNParameter) +} + +void LRNParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&norm_region_, 0, reinterpret_cast(&engine_) - + reinterpret_cast(&norm_region_) + sizeof(engine_)); + local_size_ = 5u; + alpha_ = 1; + beta_ = 0.75f; + k_ = 1; +} + +LRNParameter::~LRNParameter() { + // @@protoc_insertion_point(destructor:caffe.LRNParameter) + SharedDtor(); +} + +void LRNParameter::SharedDtor() { +} + +void LRNParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LRNParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LRNParameter_descriptor_; +} + +const LRNParameter& LRNParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed LRNParameter_default_instance_; + +LRNParameter* LRNParameter::New(::google::protobuf::Arena* arena) const { + LRNParameter* n = new LRNParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void LRNParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.LRNParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(LRNParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 63u) { + ZR_(norm_region_, engine_); + local_size_ = 5u; + alpha_ = 1; + beta_ = 0.75f; + k_ = 1; + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool LRNParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.LRNParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 local_size = 1 [default = 5]; + case 1: { + if (tag == 8) { + set_has_local_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &local_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_alpha; + break; + } + + // optional float alpha = 2 [default = 1]; + case 2: { + if (tag == 21) { + parse_alpha: + set_has_alpha(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &alpha_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_beta; + break; + } + + // optional float beta = 3 [default = 0.75]; + case 3: { + if (tag == 29) { + parse_beta: + set_has_beta(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &beta_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_norm_region; + break; + } + + // optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + case 4: { + if (tag == 32) { + parse_norm_region: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::LRNParameter_NormRegion_IsValid(value)) { + set_norm_region(static_cast< ::caffe::LRNParameter_NormRegion >(value)); + } else { + mutable_unknown_fields()->AddVarint(4, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_k; + break; + } + + // optional float k = 5 [default = 1]; + case 5: { + if (tag == 45) { + parse_k: + set_has_k(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &k_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_engine; + break; + } + + // optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + case 6: { + if (tag == 48) { + parse_engine: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::LRNParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::LRNParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.LRNParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.LRNParameter) + return false; +#undef DO_ +} + +void LRNParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.LRNParameter) + // optional uint32 local_size = 1 [default = 5]; + if (has_local_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->local_size(), output); + } + + // optional float alpha = 2 [default = 1]; + if (has_alpha()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->alpha(), output); + } + + // optional float beta = 3 [default = 0.75]; + if (has_beta()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->beta(), output); + } + + // optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + if (has_norm_region()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 4, this->norm_region(), output); + } + + // optional float k = 5 [default = 1]; + if (has_k()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->k(), output); + } + + // optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->engine(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.LRNParameter) +} + +::google::protobuf::uint8* LRNParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.LRNParameter) + // optional uint32 local_size = 1 [default = 5]; + if (has_local_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->local_size(), target); + } + + // optional float alpha = 2 [default = 1]; + if (has_alpha()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->alpha(), target); + } + + // optional float beta = 3 [default = 0.75]; + if (has_beta()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->beta(), target); + } + + // optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + if (has_norm_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 4, this->norm_region(), target); + } + + // optional float k = 5 [default = 1]; + if (has_k()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->k(), target); + } + + // optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->engine(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.LRNParameter) + return target; +} + +size_t LRNParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.LRNParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 63u) { + // optional uint32 local_size = 1 [default = 5]; + if (has_local_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->local_size()); + } + + // optional float alpha = 2 [default = 1]; + if (has_alpha()) { + total_size += 1 + 4; + } + + // optional float beta = 3 [default = 0.75]; + if (has_beta()) { + total_size += 1 + 4; + } + + // optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + if (has_norm_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->norm_region()); + } + + // optional float k = 5 [default = 1]; + if (has_k()) { + total_size += 1 + 4; + } + + // optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void LRNParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.LRNParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const LRNParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.LRNParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.LRNParameter) + UnsafeMergeFrom(*source); + } +} + +void LRNParameter::MergeFrom(const LRNParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.LRNParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void LRNParameter::UnsafeMergeFrom(const LRNParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_local_size()) { + set_local_size(from.local_size()); + } + if (from.has_alpha()) { + set_alpha(from.alpha()); + } + if (from.has_beta()) { + set_beta(from.beta()); + } + if (from.has_norm_region()) { + set_norm_region(from.norm_region()); + } + if (from.has_k()) { + set_k(from.k()); + } + if (from.has_engine()) { + set_engine(from.engine()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void LRNParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.LRNParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LRNParameter::CopyFrom(const LRNParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.LRNParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool LRNParameter::IsInitialized() const { + + return true; +} + +void LRNParameter::Swap(LRNParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void LRNParameter::InternalSwap(LRNParameter* other) { + std::swap(local_size_, other->local_size_); + std::swap(alpha_, other->alpha_); + std::swap(beta_, other->beta_); + std::swap(norm_region_, other->norm_region_); + std::swap(k_, other->k_); + std::swap(engine_, other->engine_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata LRNParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LRNParameter_descriptor_; + metadata.reflection = LRNParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// LRNParameter + +// optional uint32 local_size = 1 [default = 5]; +bool LRNParameter::has_local_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void LRNParameter::set_has_local_size() { + _has_bits_[0] |= 0x00000001u; +} +void LRNParameter::clear_has_local_size() { + _has_bits_[0] &= ~0x00000001u; +} +void LRNParameter::clear_local_size() { + local_size_ = 5u; + clear_has_local_size(); +} +::google::protobuf::uint32 LRNParameter::local_size() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.local_size) + return local_size_; +} +void LRNParameter::set_local_size(::google::protobuf::uint32 value) { + set_has_local_size(); + local_size_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.local_size) +} + +// optional float alpha = 2 [default = 1]; +bool LRNParameter::has_alpha() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void LRNParameter::set_has_alpha() { + _has_bits_[0] |= 0x00000002u; +} +void LRNParameter::clear_has_alpha() { + _has_bits_[0] &= ~0x00000002u; +} +void LRNParameter::clear_alpha() { + alpha_ = 1; + clear_has_alpha(); +} +float LRNParameter::alpha() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.alpha) + return alpha_; +} +void LRNParameter::set_alpha(float value) { + set_has_alpha(); + alpha_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.alpha) +} + +// optional float beta = 3 [default = 0.75]; +bool LRNParameter::has_beta() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void LRNParameter::set_has_beta() { + _has_bits_[0] |= 0x00000004u; +} +void LRNParameter::clear_has_beta() { + _has_bits_[0] &= ~0x00000004u; +} +void LRNParameter::clear_beta() { + beta_ = 0.75f; + clear_has_beta(); +} +float LRNParameter::beta() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.beta) + return beta_; +} +void LRNParameter::set_beta(float value) { + set_has_beta(); + beta_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.beta) +} + +// optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; +bool LRNParameter::has_norm_region() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void LRNParameter::set_has_norm_region() { + _has_bits_[0] |= 0x00000008u; +} +void LRNParameter::clear_has_norm_region() { + _has_bits_[0] &= ~0x00000008u; +} +void LRNParameter::clear_norm_region() { + norm_region_ = 0; + clear_has_norm_region(); +} +::caffe::LRNParameter_NormRegion LRNParameter::norm_region() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.norm_region) + return static_cast< ::caffe::LRNParameter_NormRegion >(norm_region_); +} +void LRNParameter::set_norm_region(::caffe::LRNParameter_NormRegion value) { + assert(::caffe::LRNParameter_NormRegion_IsValid(value)); + set_has_norm_region(); + norm_region_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.norm_region) +} + +// optional float k = 5 [default = 1]; +bool LRNParameter::has_k() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void LRNParameter::set_has_k() { + _has_bits_[0] |= 0x00000010u; +} +void LRNParameter::clear_has_k() { + _has_bits_[0] &= ~0x00000010u; +} +void LRNParameter::clear_k() { + k_ = 1; + clear_has_k(); +} +float LRNParameter::k() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.k) + return k_; +} +void LRNParameter::set_k(float value) { + set_has_k(); + k_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.k) +} + +// optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; +bool LRNParameter::has_engine() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void LRNParameter::set_has_engine() { + _has_bits_[0] |= 0x00000020u; +} +void LRNParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000020u; +} +void LRNParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::LRNParameter_Engine LRNParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.engine) + return static_cast< ::caffe::LRNParameter_Engine >(engine_); +} +void LRNParameter::set_engine(::caffe::LRNParameter_Engine value) { + assert(::caffe::LRNParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.engine) +} + +inline const LRNParameter* LRNParameter::internal_default_instance() { + return &LRNParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int MemoryDataParameter::kBatchSizeFieldNumber; +const int MemoryDataParameter::kChannelsFieldNumber; +const int MemoryDataParameter::kHeightFieldNumber; +const int MemoryDataParameter::kWidthFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +MemoryDataParameter::MemoryDataParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.MemoryDataParameter) +} + +void MemoryDataParameter::InitAsDefaultInstance() { +} + +MemoryDataParameter::MemoryDataParameter(const MemoryDataParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.MemoryDataParameter) +} + +void MemoryDataParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&batch_size_, 0, reinterpret_cast(&width_) - + reinterpret_cast(&batch_size_) + sizeof(width_)); +} + +MemoryDataParameter::~MemoryDataParameter() { + // @@protoc_insertion_point(destructor:caffe.MemoryDataParameter) + SharedDtor(); +} + +void MemoryDataParameter::SharedDtor() { +} + +void MemoryDataParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* MemoryDataParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return MemoryDataParameter_descriptor_; +} + +const MemoryDataParameter& MemoryDataParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed MemoryDataParameter_default_instance_; + +MemoryDataParameter* MemoryDataParameter::New(::google::protobuf::Arena* arena) const { + MemoryDataParameter* n = new MemoryDataParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void MemoryDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.MemoryDataParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(MemoryDataParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(batch_size_, width_); + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool MemoryDataParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.MemoryDataParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 batch_size = 1; + case 1: { + if (tag == 8) { + set_has_batch_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &batch_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_channels; + break; + } + + // optional uint32 channels = 2; + case 2: { + if (tag == 16) { + parse_channels: + set_has_channels(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &channels_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_height; + break; + } + + // optional uint32 height = 3; + case 3: { + if (tag == 24) { + parse_height: + set_has_height(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &height_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_width; + break; + } + + // optional uint32 width = 4; + case 4: { + if (tag == 32) { + parse_width: + set_has_width(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &width_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.MemoryDataParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.MemoryDataParameter) + return false; +#undef DO_ +} + +void MemoryDataParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.MemoryDataParameter) + // optional uint32 batch_size = 1; + if (has_batch_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->batch_size(), output); + } + + // optional uint32 channels = 2; + if (has_channels()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->channels(), output); + } + + // optional uint32 height = 3; + if (has_height()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->height(), output); + } + + // optional uint32 width = 4; + if (has_width()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->width(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.MemoryDataParameter) +} + +::google::protobuf::uint8* MemoryDataParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.MemoryDataParameter) + // optional uint32 batch_size = 1; + if (has_batch_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->batch_size(), target); + } + + // optional uint32 channels = 2; + if (has_channels()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->channels(), target); + } + + // optional uint32 height = 3; + if (has_height()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->height(), target); + } + + // optional uint32 width = 4; + if (has_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->width(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.MemoryDataParameter) + return target; +} + +size_t MemoryDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.MemoryDataParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 15u) { + // optional uint32 batch_size = 1; + if (has_batch_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->batch_size()); + } + + // optional uint32 channels = 2; + if (has_channels()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->channels()); + } + + // optional uint32 height = 3; + if (has_height()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->height()); + } + + // optional uint32 width = 4; + if (has_width()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->width()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void MemoryDataParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.MemoryDataParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const MemoryDataParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.MemoryDataParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.MemoryDataParameter) + UnsafeMergeFrom(*source); + } +} + +void MemoryDataParameter::MergeFrom(const MemoryDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.MemoryDataParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void MemoryDataParameter::UnsafeMergeFrom(const MemoryDataParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_batch_size()) { + set_batch_size(from.batch_size()); + } + if (from.has_channels()) { + set_channels(from.channels()); + } + if (from.has_height()) { + set_height(from.height()); + } + if (from.has_width()) { + set_width(from.width()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void MemoryDataParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.MemoryDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MemoryDataParameter::CopyFrom(const MemoryDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.MemoryDataParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool MemoryDataParameter::IsInitialized() const { + + return true; +} + +void MemoryDataParameter::Swap(MemoryDataParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void MemoryDataParameter::InternalSwap(MemoryDataParameter* other) { + std::swap(batch_size_, other->batch_size_); + std::swap(channels_, other->channels_); + std::swap(height_, other->height_); + std::swap(width_, other->width_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata MemoryDataParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = MemoryDataParameter_descriptor_; + metadata.reflection = MemoryDataParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// MemoryDataParameter + +// optional uint32 batch_size = 1; +bool MemoryDataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void MemoryDataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000001u; +} +void MemoryDataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000001u; +} +void MemoryDataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +::google::protobuf::uint32 MemoryDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.batch_size) + return batch_size_; +} +void MemoryDataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.batch_size) +} + +// optional uint32 channels = 2; +bool MemoryDataParameter::has_channels() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void MemoryDataParameter::set_has_channels() { + _has_bits_[0] |= 0x00000002u; +} +void MemoryDataParameter::clear_has_channels() { + _has_bits_[0] &= ~0x00000002u; +} +void MemoryDataParameter::clear_channels() { + channels_ = 0u; + clear_has_channels(); +} +::google::protobuf::uint32 MemoryDataParameter::channels() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.channels) + return channels_; +} +void MemoryDataParameter::set_channels(::google::protobuf::uint32 value) { + set_has_channels(); + channels_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.channels) +} + +// optional uint32 height = 3; +bool MemoryDataParameter::has_height() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void MemoryDataParameter::set_has_height() { + _has_bits_[0] |= 0x00000004u; +} +void MemoryDataParameter::clear_has_height() { + _has_bits_[0] &= ~0x00000004u; +} +void MemoryDataParameter::clear_height() { + height_ = 0u; + clear_has_height(); +} +::google::protobuf::uint32 MemoryDataParameter::height() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.height) + return height_; +} +void MemoryDataParameter::set_height(::google::protobuf::uint32 value) { + set_has_height(); + height_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.height) +} + +// optional uint32 width = 4; +bool MemoryDataParameter::has_width() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void MemoryDataParameter::set_has_width() { + _has_bits_[0] |= 0x00000008u; +} +void MemoryDataParameter::clear_has_width() { + _has_bits_[0] &= ~0x00000008u; +} +void MemoryDataParameter::clear_width() { + width_ = 0u; + clear_has_width(); +} +::google::protobuf::uint32 MemoryDataParameter::width() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.width) + return width_; +} +void MemoryDataParameter::set_width(::google::protobuf::uint32 value) { + set_has_width(); + width_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.width) +} + +inline const MemoryDataParameter* MemoryDataParameter::internal_default_instance() { + return &MemoryDataParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int MVNParameter::kNormalizeVarianceFieldNumber; +const int MVNParameter::kAcrossChannelsFieldNumber; +const int MVNParameter::kEpsFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +MVNParameter::MVNParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.MVNParameter) +} + +void MVNParameter::InitAsDefaultInstance() { +} + +MVNParameter::MVNParameter(const MVNParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.MVNParameter) +} + +void MVNParameter::SharedCtor() { + _cached_size_ = 0; + across_channels_ = false; + normalize_variance_ = true; + eps_ = 1e-09f; +} + +MVNParameter::~MVNParameter() { + // @@protoc_insertion_point(destructor:caffe.MVNParameter) + SharedDtor(); +} + +void MVNParameter::SharedDtor() { +} + +void MVNParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* MVNParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return MVNParameter_descriptor_; +} + +const MVNParameter& MVNParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed MVNParameter_default_instance_; + +MVNParameter* MVNParameter::New(::google::protobuf::Arena* arena) const { + MVNParameter* n = new MVNParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void MVNParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.MVNParameter) + if (_has_bits_[0 / 32] & 7u) { + normalize_variance_ = true; + across_channels_ = false; + eps_ = 1e-09f; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool MVNParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.MVNParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bool normalize_variance = 1 [default = true]; + case 1: { + if (tag == 8) { + set_has_normalize_variance(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &normalize_variance_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_across_channels; + break; + } + + // optional bool across_channels = 2 [default = false]; + case 2: { + if (tag == 16) { + parse_across_channels: + set_has_across_channels(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &across_channels_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_eps; + break; + } + + // optional float eps = 3 [default = 1e-09]; + case 3: { + if (tag == 29) { + parse_eps: + set_has_eps(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &eps_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.MVNParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.MVNParameter) + return false; +#undef DO_ +} + +void MVNParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.MVNParameter) + // optional bool normalize_variance = 1 [default = true]; + if (has_normalize_variance()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->normalize_variance(), output); + } + + // optional bool across_channels = 2 [default = false]; + if (has_across_channels()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->across_channels(), output); + } + + // optional float eps = 3 [default = 1e-09]; + if (has_eps()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->eps(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.MVNParameter) +} + +::google::protobuf::uint8* MVNParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.MVNParameter) + // optional bool normalize_variance = 1 [default = true]; + if (has_normalize_variance()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->normalize_variance(), target); + } + + // optional bool across_channels = 2 [default = false]; + if (has_across_channels()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->across_channels(), target); + } + + // optional float eps = 3 [default = 1e-09]; + if (has_eps()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->eps(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.MVNParameter) + return target; +} + +size_t MVNParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.MVNParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional bool normalize_variance = 1 [default = true]; + if (has_normalize_variance()) { + total_size += 1 + 1; + } + + // optional bool across_channels = 2 [default = false]; + if (has_across_channels()) { + total_size += 1 + 1; + } + + // optional float eps = 3 [default = 1e-09]; + if (has_eps()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void MVNParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.MVNParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const MVNParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.MVNParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.MVNParameter) + UnsafeMergeFrom(*source); + } +} + +void MVNParameter::MergeFrom(const MVNParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.MVNParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void MVNParameter::UnsafeMergeFrom(const MVNParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_normalize_variance()) { + set_normalize_variance(from.normalize_variance()); + } + if (from.has_across_channels()) { + set_across_channels(from.across_channels()); + } + if (from.has_eps()) { + set_eps(from.eps()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void MVNParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.MVNParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MVNParameter::CopyFrom(const MVNParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.MVNParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool MVNParameter::IsInitialized() const { + + return true; +} + +void MVNParameter::Swap(MVNParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void MVNParameter::InternalSwap(MVNParameter* other) { + std::swap(normalize_variance_, other->normalize_variance_); + std::swap(across_channels_, other->across_channels_); + std::swap(eps_, other->eps_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata MVNParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = MVNParameter_descriptor_; + metadata.reflection = MVNParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// MVNParameter + +// optional bool normalize_variance = 1 [default = true]; +bool MVNParameter::has_normalize_variance() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void MVNParameter::set_has_normalize_variance() { + _has_bits_[0] |= 0x00000001u; +} +void MVNParameter::clear_has_normalize_variance() { + _has_bits_[0] &= ~0x00000001u; +} +void MVNParameter::clear_normalize_variance() { + normalize_variance_ = true; + clear_has_normalize_variance(); +} +bool MVNParameter::normalize_variance() const { + // @@protoc_insertion_point(field_get:caffe.MVNParameter.normalize_variance) + return normalize_variance_; +} +void MVNParameter::set_normalize_variance(bool value) { + set_has_normalize_variance(); + normalize_variance_ = value; + // @@protoc_insertion_point(field_set:caffe.MVNParameter.normalize_variance) +} + +// optional bool across_channels = 2 [default = false]; +bool MVNParameter::has_across_channels() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void MVNParameter::set_has_across_channels() { + _has_bits_[0] |= 0x00000002u; +} +void MVNParameter::clear_has_across_channels() { + _has_bits_[0] &= ~0x00000002u; +} +void MVNParameter::clear_across_channels() { + across_channels_ = false; + clear_has_across_channels(); +} +bool MVNParameter::across_channels() const { + // @@protoc_insertion_point(field_get:caffe.MVNParameter.across_channels) + return across_channels_; +} +void MVNParameter::set_across_channels(bool value) { + set_has_across_channels(); + across_channels_ = value; + // @@protoc_insertion_point(field_set:caffe.MVNParameter.across_channels) +} + +// optional float eps = 3 [default = 1e-09]; +bool MVNParameter::has_eps() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void MVNParameter::set_has_eps() { + _has_bits_[0] |= 0x00000004u; +} +void MVNParameter::clear_has_eps() { + _has_bits_[0] &= ~0x00000004u; +} +void MVNParameter::clear_eps() { + eps_ = 1e-09f; + clear_has_eps(); +} +float MVNParameter::eps() const { + // @@protoc_insertion_point(field_get:caffe.MVNParameter.eps) + return eps_; +} +void MVNParameter::set_eps(float value) { + set_has_eps(); + eps_ = value; + // @@protoc_insertion_point(field_set:caffe.MVNParameter.eps) +} + +inline const MVNParameter* MVNParameter::internal_default_instance() { + return &MVNParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ParameterParameter::kShapeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ParameterParameter::ParameterParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ParameterParameter) +} + +void ParameterParameter::InitAsDefaultInstance() { + shape_ = const_cast< ::caffe::BlobShape*>( + ::caffe::BlobShape::internal_default_instance()); +} + +ParameterParameter::ParameterParameter(const ParameterParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ParameterParameter) +} + +void ParameterParameter::SharedCtor() { + _cached_size_ = 0; + shape_ = NULL; +} + +ParameterParameter::~ParameterParameter() { + // @@protoc_insertion_point(destructor:caffe.ParameterParameter) + SharedDtor(); +} + +void ParameterParameter::SharedDtor() { + if (this != &ParameterParameter_default_instance_.get()) { + delete shape_; + } +} + +void ParameterParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ParameterParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ParameterParameter_descriptor_; +} + +const ParameterParameter& ParameterParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ParameterParameter_default_instance_; + +ParameterParameter* ParameterParameter::New(::google::protobuf::Arena* arena) const { + ParameterParameter* n = new ParameterParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ParameterParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ParameterParameter) + if (has_shape()) { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ParameterParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ParameterParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.BlobShape shape = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ParameterParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ParameterParameter) + return false; +#undef DO_ +} + +void ParameterParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ParameterParameter) + // optional .caffe.BlobShape shape = 1; + if (has_shape()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, *this->shape_, output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ParameterParameter) +} + +::google::protobuf::uint8* ParameterParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ParameterParameter) + // optional .caffe.BlobShape shape = 1; + if (has_shape()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, *this->shape_, false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ParameterParameter) + return target; +} + +size_t ParameterParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ParameterParameter) + size_t total_size = 0; + + // optional .caffe.BlobShape shape = 1; + if (has_shape()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->shape_); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ParameterParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ParameterParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ParameterParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ParameterParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ParameterParameter) + UnsafeMergeFrom(*source); + } +} + +void ParameterParameter::MergeFrom(const ParameterParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ParameterParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ParameterParameter::UnsafeMergeFrom(const ParameterParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_shape()) { + mutable_shape()->::caffe::BlobShape::MergeFrom(from.shape()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ParameterParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ParameterParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterParameter::CopyFrom(const ParameterParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ParameterParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ParameterParameter::IsInitialized() const { + + return true; +} + +void ParameterParameter::Swap(ParameterParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ParameterParameter::InternalSwap(ParameterParameter* other) { + std::swap(shape_, other->shape_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ParameterParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ParameterParameter_descriptor_; + metadata.reflection = ParameterParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ParameterParameter + +// optional .caffe.BlobShape shape = 1; +bool ParameterParameter::has_shape() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ParameterParameter::set_has_shape() { + _has_bits_[0] |= 0x00000001u; +} +void ParameterParameter::clear_has_shape() { + _has_bits_[0] &= ~0x00000001u; +} +void ParameterParameter::clear_shape() { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + clear_has_shape(); +} +const ::caffe::BlobShape& ParameterParameter::shape() const { + // @@protoc_insertion_point(field_get:caffe.ParameterParameter.shape) + return shape_ != NULL ? *shape_ + : *::caffe::BlobShape::internal_default_instance(); +} +::caffe::BlobShape* ParameterParameter::mutable_shape() { + set_has_shape(); + if (shape_ == NULL) { + shape_ = new ::caffe::BlobShape; + } + // @@protoc_insertion_point(field_mutable:caffe.ParameterParameter.shape) + return shape_; +} +::caffe::BlobShape* ParameterParameter::release_shape() { + // @@protoc_insertion_point(field_release:caffe.ParameterParameter.shape) + clear_has_shape(); + ::caffe::BlobShape* temp = shape_; + shape_ = NULL; + return temp; +} +void ParameterParameter::set_allocated_shape(::caffe::BlobShape* shape) { + delete shape_; + shape_ = shape; + if (shape) { + set_has_shape(); + } else { + clear_has_shape(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ParameterParameter.shape) +} + +inline const ParameterParameter* ParameterParameter::internal_default_instance() { + return &ParameterParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* PoolingParameter_PoolMethod_descriptor() { + protobuf_AssignDescriptorsOnce(); + return PoolingParameter_PoolMethod_descriptor_; +} +bool PoolingParameter_PoolMethod_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const PoolingParameter_PoolMethod PoolingParameter::MAX; +const PoolingParameter_PoolMethod PoolingParameter::AVE; +const PoolingParameter_PoolMethod PoolingParameter::STOCHASTIC; +const PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MIN; +const PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MAX; +const int PoolingParameter::PoolMethod_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* PoolingParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return PoolingParameter_Engine_descriptor_; +} +bool PoolingParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const PoolingParameter_Engine PoolingParameter::DEFAULT; +const PoolingParameter_Engine PoolingParameter::CAFFE; +const PoolingParameter_Engine PoolingParameter::CUDNN; +const PoolingParameter_Engine PoolingParameter::Engine_MIN; +const PoolingParameter_Engine PoolingParameter::Engine_MAX; +const int PoolingParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int PoolingParameter::kPoolFieldNumber; +const int PoolingParameter::kPadFieldNumber; +const int PoolingParameter::kPadHFieldNumber; +const int PoolingParameter::kPadWFieldNumber; +const int PoolingParameter::kKernelSizeFieldNumber; +const int PoolingParameter::kKernelHFieldNumber; +const int PoolingParameter::kKernelWFieldNumber; +const int PoolingParameter::kStrideFieldNumber; +const int PoolingParameter::kStrideHFieldNumber; +const int PoolingParameter::kStrideWFieldNumber; +const int PoolingParameter::kEngineFieldNumber; +const int PoolingParameter::kGlobalPoolingFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +PoolingParameter::PoolingParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.PoolingParameter) +} + +void PoolingParameter::InitAsDefaultInstance() { +} + +PoolingParameter::PoolingParameter(const PoolingParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.PoolingParameter) +} + +void PoolingParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&pool_, 0, reinterpret_cast(&global_pooling_) - + reinterpret_cast(&pool_) + sizeof(global_pooling_)); + stride_ = 1u; +} + +PoolingParameter::~PoolingParameter() { + // @@protoc_insertion_point(destructor:caffe.PoolingParameter) + SharedDtor(); +} + +void PoolingParameter::SharedDtor() { +} + +void PoolingParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PoolingParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PoolingParameter_descriptor_; +} + +const PoolingParameter& PoolingParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed PoolingParameter_default_instance_; + +PoolingParameter* PoolingParameter::New(::google::protobuf::Arena* arena) const { + PoolingParameter* n = new PoolingParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void PoolingParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.PoolingParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(PoolingParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 255u) { + ZR_(pool_, kernel_w_); + stride_ = 1u; + } + ZR_(stride_h_, global_pooling_); + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool PoolingParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.PoolingParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::PoolingParameter_PoolMethod_IsValid(value)) { + set_pool(static_cast< ::caffe::PoolingParameter_PoolMethod >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_kernel_size; + break; + } + + // optional uint32 kernel_size = 2; + case 2: { + if (tag == 16) { + parse_kernel_size: + set_has_kernel_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &kernel_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_stride; + break; + } + + // optional uint32 stride = 3 [default = 1]; + case 3: { + if (tag == 24) { + parse_stride: + set_has_stride(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stride_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_pad; + break; + } + + // optional uint32 pad = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_pad: + set_has_pad(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &pad_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_kernel_h; + break; + } + + // optional uint32 kernel_h = 5; + case 5: { + if (tag == 40) { + parse_kernel_h: + set_has_kernel_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &kernel_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_kernel_w; + break; + } + + // optional uint32 kernel_w = 6; + case 6: { + if (tag == 48) { + parse_kernel_w: + set_has_kernel_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &kernel_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_stride_h; + break; + } + + // optional uint32 stride_h = 7; + case 7: { + if (tag == 56) { + parse_stride_h: + set_has_stride_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stride_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_stride_w; + break; + } + + // optional uint32 stride_w = 8; + case 8: { + if (tag == 64) { + parse_stride_w: + set_has_stride_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stride_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_pad_h; + break; + } + + // optional uint32 pad_h = 9 [default = 0]; + case 9: { + if (tag == 72) { + parse_pad_h: + set_has_pad_h(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &pad_h_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_pad_w; + break; + } + + // optional uint32 pad_w = 10 [default = 0]; + case 10: { + if (tag == 80) { + parse_pad_w: + set_has_pad_w(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &pad_w_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_engine; + break; + } + + // optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + case 11: { + if (tag == 88) { + parse_engine: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::PoolingParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::PoolingParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(11, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_global_pooling; + break; + } + + // optional bool global_pooling = 12 [default = false]; + case 12: { + if (tag == 96) { + parse_global_pooling: + set_has_global_pooling(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &global_pooling_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.PoolingParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.PoolingParameter) + return false; +#undef DO_ +} + +void PoolingParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.PoolingParameter) + // optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + if (has_pool()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->pool(), output); + } + + // optional uint32 kernel_size = 2; + if (has_kernel_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->kernel_size(), output); + } + + // optional uint32 stride = 3 [default = 1]; + if (has_stride()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stride(), output); + } + + // optional uint32 pad = 4 [default = 0]; + if (has_pad()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->pad(), output); + } + + // optional uint32 kernel_h = 5; + if (has_kernel_h()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->kernel_h(), output); + } + + // optional uint32 kernel_w = 6; + if (has_kernel_w()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->kernel_w(), output); + } + + // optional uint32 stride_h = 7; + if (has_stride_h()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->stride_h(), output); + } + + // optional uint32 stride_w = 8; + if (has_stride_w()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->stride_w(), output); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (has_pad_h()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->pad_h(), output); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (has_pad_w()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->pad_w(), output); + } + + // optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 11, this->engine(), output); + } + + // optional bool global_pooling = 12 [default = false]; + if (has_global_pooling()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->global_pooling(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.PoolingParameter) +} + +::google::protobuf::uint8* PoolingParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.PoolingParameter) + // optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + if (has_pool()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->pool(), target); + } + + // optional uint32 kernel_size = 2; + if (has_kernel_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->kernel_size(), target); + } + + // optional uint32 stride = 3 [default = 1]; + if (has_stride()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->stride(), target); + } + + // optional uint32 pad = 4 [default = 0]; + if (has_pad()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->pad(), target); + } + + // optional uint32 kernel_h = 5; + if (has_kernel_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->kernel_h(), target); + } + + // optional uint32 kernel_w = 6; + if (has_kernel_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->kernel_w(), target); + } + + // optional uint32 stride_h = 7; + if (has_stride_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->stride_h(), target); + } + + // optional uint32 stride_w = 8; + if (has_stride_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->stride_w(), target); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (has_pad_h()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->pad_h(), target); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (has_pad_w()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->pad_w(), target); + } + + // optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 11, this->engine(), target); + } + + // optional bool global_pooling = 12 [default = false]; + if (has_global_pooling()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->global_pooling(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.PoolingParameter) + return target; +} + +size_t PoolingParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.PoolingParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + if (has_pool()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->pool()); + } + + // optional uint32 pad = 4 [default = 0]; + if (has_pad()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->pad()); + } + + // optional uint32 pad_h = 9 [default = 0]; + if (has_pad_h()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->pad_h()); + } + + // optional uint32 pad_w = 10 [default = 0]; + if (has_pad_w()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->pad_w()); + } + + // optional uint32 kernel_size = 2; + if (has_kernel_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->kernel_size()); + } + + // optional uint32 kernel_h = 5; + if (has_kernel_h()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->kernel_h()); + } + + // optional uint32 kernel_w = 6; + if (has_kernel_w()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->kernel_w()); + } + + // optional uint32 stride = 3 [default = 1]; + if (has_stride()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stride()); + } + + } + if (_has_bits_[8 / 32] & 3840u) { + // optional uint32 stride_h = 7; + if (has_stride_h()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stride_h()); + } + + // optional uint32 stride_w = 8; + if (has_stride_w()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stride_w()); + } + + // optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + // optional bool global_pooling = 12 [default = false]; + if (has_global_pooling()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PoolingParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.PoolingParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const PoolingParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.PoolingParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.PoolingParameter) + UnsafeMergeFrom(*source); + } +} + +void PoolingParameter::MergeFrom(const PoolingParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.PoolingParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void PoolingParameter::UnsafeMergeFrom(const PoolingParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_pool()) { + set_pool(from.pool()); + } + if (from.has_pad()) { + set_pad(from.pad()); + } + if (from.has_pad_h()) { + set_pad_h(from.pad_h()); + } + if (from.has_pad_w()) { + set_pad_w(from.pad_w()); + } + if (from.has_kernel_size()) { + set_kernel_size(from.kernel_size()); + } + if (from.has_kernel_h()) { + set_kernel_h(from.kernel_h()); + } + if (from.has_kernel_w()) { + set_kernel_w(from.kernel_w()); + } + if (from.has_stride()) { + set_stride(from.stride()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_stride_h()) { + set_stride_h(from.stride_h()); + } + if (from.has_stride_w()) { + set_stride_w(from.stride_w()); + } + if (from.has_engine()) { + set_engine(from.engine()); + } + if (from.has_global_pooling()) { + set_global_pooling(from.global_pooling()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void PoolingParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.PoolingParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PoolingParameter::CopyFrom(const PoolingParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.PoolingParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool PoolingParameter::IsInitialized() const { + + return true; +} + +void PoolingParameter::Swap(PoolingParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void PoolingParameter::InternalSwap(PoolingParameter* other) { + std::swap(pool_, other->pool_); + std::swap(pad_, other->pad_); + std::swap(pad_h_, other->pad_h_); + std::swap(pad_w_, other->pad_w_); + std::swap(kernel_size_, other->kernel_size_); + std::swap(kernel_h_, other->kernel_h_); + std::swap(kernel_w_, other->kernel_w_); + std::swap(stride_, other->stride_); + std::swap(stride_h_, other->stride_h_); + std::swap(stride_w_, other->stride_w_); + std::swap(engine_, other->engine_); + std::swap(global_pooling_, other->global_pooling_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata PoolingParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PoolingParameter_descriptor_; + metadata.reflection = PoolingParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// PoolingParameter + +// optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; +bool PoolingParameter::has_pool() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void PoolingParameter::set_has_pool() { + _has_bits_[0] |= 0x00000001u; +} +void PoolingParameter::clear_has_pool() { + _has_bits_[0] &= ~0x00000001u; +} +void PoolingParameter::clear_pool() { + pool_ = 0; + clear_has_pool(); +} +::caffe::PoolingParameter_PoolMethod PoolingParameter::pool() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pool) + return static_cast< ::caffe::PoolingParameter_PoolMethod >(pool_); +} +void PoolingParameter::set_pool(::caffe::PoolingParameter_PoolMethod value) { + assert(::caffe::PoolingParameter_PoolMethod_IsValid(value)); + set_has_pool(); + pool_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pool) +} + +// optional uint32 pad = 4 [default = 0]; +bool PoolingParameter::has_pad() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void PoolingParameter::set_has_pad() { + _has_bits_[0] |= 0x00000002u; +} +void PoolingParameter::clear_has_pad() { + _has_bits_[0] &= ~0x00000002u; +} +void PoolingParameter::clear_pad() { + pad_ = 0u; + clear_has_pad(); +} +::google::protobuf::uint32 PoolingParameter::pad() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad) + return pad_; +} +void PoolingParameter::set_pad(::google::protobuf::uint32 value) { + set_has_pad(); + pad_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad) +} + +// optional uint32 pad_h = 9 [default = 0]; +bool PoolingParameter::has_pad_h() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void PoolingParameter::set_has_pad_h() { + _has_bits_[0] |= 0x00000004u; +} +void PoolingParameter::clear_has_pad_h() { + _has_bits_[0] &= ~0x00000004u; +} +void PoolingParameter::clear_pad_h() { + pad_h_ = 0u; + clear_has_pad_h(); +} +::google::protobuf::uint32 PoolingParameter::pad_h() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad_h) + return pad_h_; +} +void PoolingParameter::set_pad_h(::google::protobuf::uint32 value) { + set_has_pad_h(); + pad_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad_h) +} + +// optional uint32 pad_w = 10 [default = 0]; +bool PoolingParameter::has_pad_w() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void PoolingParameter::set_has_pad_w() { + _has_bits_[0] |= 0x00000008u; +} +void PoolingParameter::clear_has_pad_w() { + _has_bits_[0] &= ~0x00000008u; +} +void PoolingParameter::clear_pad_w() { + pad_w_ = 0u; + clear_has_pad_w(); +} +::google::protobuf::uint32 PoolingParameter::pad_w() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad_w) + return pad_w_; +} +void PoolingParameter::set_pad_w(::google::protobuf::uint32 value) { + set_has_pad_w(); + pad_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad_w) +} + +// optional uint32 kernel_size = 2; +bool PoolingParameter::has_kernel_size() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void PoolingParameter::set_has_kernel_size() { + _has_bits_[0] |= 0x00000010u; +} +void PoolingParameter::clear_has_kernel_size() { + _has_bits_[0] &= ~0x00000010u; +} +void PoolingParameter::clear_kernel_size() { + kernel_size_ = 0u; + clear_has_kernel_size(); +} +::google::protobuf::uint32 PoolingParameter::kernel_size() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_size) + return kernel_size_; +} +void PoolingParameter::set_kernel_size(::google::protobuf::uint32 value) { + set_has_kernel_size(); + kernel_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_size) +} + +// optional uint32 kernel_h = 5; +bool PoolingParameter::has_kernel_h() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void PoolingParameter::set_has_kernel_h() { + _has_bits_[0] |= 0x00000020u; +} +void PoolingParameter::clear_has_kernel_h() { + _has_bits_[0] &= ~0x00000020u; +} +void PoolingParameter::clear_kernel_h() { + kernel_h_ = 0u; + clear_has_kernel_h(); +} +::google::protobuf::uint32 PoolingParameter::kernel_h() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_h) + return kernel_h_; +} +void PoolingParameter::set_kernel_h(::google::protobuf::uint32 value) { + set_has_kernel_h(); + kernel_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_h) +} + +// optional uint32 kernel_w = 6; +bool PoolingParameter::has_kernel_w() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void PoolingParameter::set_has_kernel_w() { + _has_bits_[0] |= 0x00000040u; +} +void PoolingParameter::clear_has_kernel_w() { + _has_bits_[0] &= ~0x00000040u; +} +void PoolingParameter::clear_kernel_w() { + kernel_w_ = 0u; + clear_has_kernel_w(); +} +::google::protobuf::uint32 PoolingParameter::kernel_w() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_w) + return kernel_w_; +} +void PoolingParameter::set_kernel_w(::google::protobuf::uint32 value) { + set_has_kernel_w(); + kernel_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_w) +} + +// optional uint32 stride = 3 [default = 1]; +bool PoolingParameter::has_stride() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void PoolingParameter::set_has_stride() { + _has_bits_[0] |= 0x00000080u; +} +void PoolingParameter::clear_has_stride() { + _has_bits_[0] &= ~0x00000080u; +} +void PoolingParameter::clear_stride() { + stride_ = 1u; + clear_has_stride(); +} +::google::protobuf::uint32 PoolingParameter::stride() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride) + return stride_; +} +void PoolingParameter::set_stride(::google::protobuf::uint32 value) { + set_has_stride(); + stride_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride) +} + +// optional uint32 stride_h = 7; +bool PoolingParameter::has_stride_h() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void PoolingParameter::set_has_stride_h() { + _has_bits_[0] |= 0x00000100u; +} +void PoolingParameter::clear_has_stride_h() { + _has_bits_[0] &= ~0x00000100u; +} +void PoolingParameter::clear_stride_h() { + stride_h_ = 0u; + clear_has_stride_h(); +} +::google::protobuf::uint32 PoolingParameter::stride_h() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride_h) + return stride_h_; +} +void PoolingParameter::set_stride_h(::google::protobuf::uint32 value) { + set_has_stride_h(); + stride_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride_h) +} + +// optional uint32 stride_w = 8; +bool PoolingParameter::has_stride_w() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void PoolingParameter::set_has_stride_w() { + _has_bits_[0] |= 0x00000200u; +} +void PoolingParameter::clear_has_stride_w() { + _has_bits_[0] &= ~0x00000200u; +} +void PoolingParameter::clear_stride_w() { + stride_w_ = 0u; + clear_has_stride_w(); +} +::google::protobuf::uint32 PoolingParameter::stride_w() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride_w) + return stride_w_; +} +void PoolingParameter::set_stride_w(::google::protobuf::uint32 value) { + set_has_stride_w(); + stride_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride_w) +} + +// optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; +bool PoolingParameter::has_engine() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +void PoolingParameter::set_has_engine() { + _has_bits_[0] |= 0x00000400u; +} +void PoolingParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000400u; +} +void PoolingParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::PoolingParameter_Engine PoolingParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.engine) + return static_cast< ::caffe::PoolingParameter_Engine >(engine_); +} +void PoolingParameter::set_engine(::caffe::PoolingParameter_Engine value) { + assert(::caffe::PoolingParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.engine) +} + +// optional bool global_pooling = 12 [default = false]; +bool PoolingParameter::has_global_pooling() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void PoolingParameter::set_has_global_pooling() { + _has_bits_[0] |= 0x00000800u; +} +void PoolingParameter::clear_has_global_pooling() { + _has_bits_[0] &= ~0x00000800u; +} +void PoolingParameter::clear_global_pooling() { + global_pooling_ = false; + clear_has_global_pooling(); +} +bool PoolingParameter::global_pooling() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.global_pooling) + return global_pooling_; +} +void PoolingParameter::set_global_pooling(bool value) { + set_has_global_pooling(); + global_pooling_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.global_pooling) +} + +inline const PoolingParameter* PoolingParameter::internal_default_instance() { + return &PoolingParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int PowerParameter::kPowerFieldNumber; +const int PowerParameter::kScaleFieldNumber; +const int PowerParameter::kShiftFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +PowerParameter::PowerParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.PowerParameter) +} + +void PowerParameter::InitAsDefaultInstance() { +} + +PowerParameter::PowerParameter(const PowerParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.PowerParameter) +} + +void PowerParameter::SharedCtor() { + _cached_size_ = 0; + shift_ = 0; + power_ = 1; + scale_ = 1; +} + +PowerParameter::~PowerParameter() { + // @@protoc_insertion_point(destructor:caffe.PowerParameter) + SharedDtor(); +} + +void PowerParameter::SharedDtor() { +} + +void PowerParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PowerParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PowerParameter_descriptor_; +} + +const PowerParameter& PowerParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed PowerParameter_default_instance_; + +PowerParameter* PowerParameter::New(::google::protobuf::Arena* arena) const { + PowerParameter* n = new PowerParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void PowerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.PowerParameter) + if (_has_bits_[0 / 32] & 7u) { + power_ = 1; + scale_ = 1; + shift_ = 0; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool PowerParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.PowerParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float power = 1 [default = 1]; + case 1: { + if (tag == 13) { + set_has_power(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &power_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_scale; + break; + } + + // optional float scale = 2 [default = 1]; + case 2: { + if (tag == 21) { + parse_scale: + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_shift; + break; + } + + // optional float shift = 3 [default = 0]; + case 3: { + if (tag == 29) { + parse_shift: + set_has_shift(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &shift_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.PowerParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.PowerParameter) + return false; +#undef DO_ +} + +void PowerParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.PowerParameter) + // optional float power = 1 [default = 1]; + if (has_power()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->power(), output); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output); + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->shift(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.PowerParameter) +} + +::google::protobuf::uint8* PowerParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.PowerParameter) + // optional float power = 1 [default = 1]; + if (has_power()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->power(), target); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target); + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->shift(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.PowerParameter) + return target; +} + +size_t PowerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.PowerParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional float power = 1 [default = 1]; + if (has_power()) { + total_size += 1 + 4; + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + total_size += 1 + 4; + } + + // optional float shift = 3 [default = 0]; + if (has_shift()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PowerParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.PowerParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const PowerParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.PowerParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.PowerParameter) + UnsafeMergeFrom(*source); + } +} + +void PowerParameter::MergeFrom(const PowerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.PowerParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void PowerParameter::UnsafeMergeFrom(const PowerParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_power()) { + set_power(from.power()); + } + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_shift()) { + set_shift(from.shift()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void PowerParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.PowerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PowerParameter::CopyFrom(const PowerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.PowerParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool PowerParameter::IsInitialized() const { + + return true; +} + +void PowerParameter::Swap(PowerParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void PowerParameter::InternalSwap(PowerParameter* other) { + std::swap(power_, other->power_); + std::swap(scale_, other->scale_); + std::swap(shift_, other->shift_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata PowerParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PowerParameter_descriptor_; + metadata.reflection = PowerParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// PowerParameter + +// optional float power = 1 [default = 1]; +bool PowerParameter::has_power() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void PowerParameter::set_has_power() { + _has_bits_[0] |= 0x00000001u; +} +void PowerParameter::clear_has_power() { + _has_bits_[0] &= ~0x00000001u; +} +void PowerParameter::clear_power() { + power_ = 1; + clear_has_power(); +} +float PowerParameter::power() const { + // @@protoc_insertion_point(field_get:caffe.PowerParameter.power) + return power_; +} +void PowerParameter::set_power(float value) { + set_has_power(); + power_ = value; + // @@protoc_insertion_point(field_set:caffe.PowerParameter.power) +} + +// optional float scale = 2 [default = 1]; +bool PowerParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void PowerParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +void PowerParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +void PowerParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float PowerParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.PowerParameter.scale) + return scale_; +} +void PowerParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.PowerParameter.scale) +} + +// optional float shift = 3 [default = 0]; +bool PowerParameter::has_shift() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void PowerParameter::set_has_shift() { + _has_bits_[0] |= 0x00000004u; +} +void PowerParameter::clear_has_shift() { + _has_bits_[0] &= ~0x00000004u; +} +void PowerParameter::clear_shift() { + shift_ = 0; + clear_has_shift(); +} +float PowerParameter::shift() const { + // @@protoc_insertion_point(field_get:caffe.PowerParameter.shift) + return shift_; +} +void PowerParameter::set_shift(float value) { + set_has_shift(); + shift_ = value; + // @@protoc_insertion_point(field_set:caffe.PowerParameter.shift) +} + +inline const PowerParameter* PowerParameter::internal_default_instance() { + return &PowerParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int PythonParameter::kModuleFieldNumber; +const int PythonParameter::kLayerFieldNumber; +const int PythonParameter::kParamStrFieldNumber; +const int PythonParameter::kShareInParallelFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +PythonParameter::PythonParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.PythonParameter) +} + +void PythonParameter::InitAsDefaultInstance() { +} + +PythonParameter::PythonParameter(const PythonParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.PythonParameter) +} + +void PythonParameter::SharedCtor() { + _cached_size_ = 0; + module_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + layer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + param_str_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + share_in_parallel_ = false; +} + +PythonParameter::~PythonParameter() { + // @@protoc_insertion_point(destructor:caffe.PythonParameter) + SharedDtor(); +} + +void PythonParameter::SharedDtor() { + module_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + layer_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + param_str_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void PythonParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PythonParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PythonParameter_descriptor_; +} + +const PythonParameter& PythonParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed PythonParameter_default_instance_; + +PythonParameter* PythonParameter::New(::google::protobuf::Arena* arena) const { + PythonParameter* n = new PythonParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void PythonParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.PythonParameter) + if (_has_bits_[0 / 32] & 15u) { + if (has_module()) { + module_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_layer()) { + layer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_param_str()) { + param_str_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + share_in_parallel_ = false; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool PythonParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.PythonParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string module = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_module())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->module().data(), this->module().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.PythonParameter.module"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_layer; + break; + } + + // optional string layer = 2; + case 2: { + if (tag == 18) { + parse_layer: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_layer())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->layer().data(), this->layer().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.PythonParameter.layer"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_param_str; + break; + } + + // optional string param_str = 3 [default = ""]; + case 3: { + if (tag == 26) { + parse_param_str: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_param_str())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->param_str().data(), this->param_str().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.PythonParameter.param_str"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_share_in_parallel; + break; + } + + // optional bool share_in_parallel = 4 [default = false]; + case 4: { + if (tag == 32) { + parse_share_in_parallel: + set_has_share_in_parallel(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &share_in_parallel_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.PythonParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.PythonParameter) + return false; +#undef DO_ +} + +void PythonParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.PythonParameter) + // optional string module = 1; + if (has_module()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->module().data(), this->module().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.PythonParameter.module"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->module(), output); + } + + // optional string layer = 2; + if (has_layer()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->layer().data(), this->layer().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.PythonParameter.layer"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->layer(), output); + } + + // optional string param_str = 3 [default = ""]; + if (has_param_str()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->param_str().data(), this->param_str().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.PythonParameter.param_str"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->param_str(), output); + } + + // optional bool share_in_parallel = 4 [default = false]; + if (has_share_in_parallel()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->share_in_parallel(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.PythonParameter) +} + +::google::protobuf::uint8* PythonParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.PythonParameter) + // optional string module = 1; + if (has_module()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->module().data(), this->module().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.PythonParameter.module"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->module(), target); + } + + // optional string layer = 2; + if (has_layer()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->layer().data(), this->layer().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.PythonParameter.layer"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->layer(), target); + } + + // optional string param_str = 3 [default = ""]; + if (has_param_str()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->param_str().data(), this->param_str().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.PythonParameter.param_str"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->param_str(), target); + } + + // optional bool share_in_parallel = 4 [default = false]; + if (has_share_in_parallel()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->share_in_parallel(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.PythonParameter) + return target; +} + +size_t PythonParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.PythonParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 15u) { + // optional string module = 1; + if (has_module()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->module()); + } + + // optional string layer = 2; + if (has_layer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->layer()); + } + + // optional string param_str = 3 [default = ""]; + if (has_param_str()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->param_str()); + } + + // optional bool share_in_parallel = 4 [default = false]; + if (has_share_in_parallel()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PythonParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.PythonParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const PythonParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.PythonParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.PythonParameter) + UnsafeMergeFrom(*source); + } +} + +void PythonParameter::MergeFrom(const PythonParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.PythonParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void PythonParameter::UnsafeMergeFrom(const PythonParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_module()) { + set_has_module(); + module_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.module_); + } + if (from.has_layer()) { + set_has_layer(); + layer_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.layer_); + } + if (from.has_param_str()) { + set_has_param_str(); + param_str_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.param_str_); + } + if (from.has_share_in_parallel()) { + set_share_in_parallel(from.share_in_parallel()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void PythonParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.PythonParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PythonParameter::CopyFrom(const PythonParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.PythonParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool PythonParameter::IsInitialized() const { + + return true; +} + +void PythonParameter::Swap(PythonParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void PythonParameter::InternalSwap(PythonParameter* other) { + module_.Swap(&other->module_); + layer_.Swap(&other->layer_); + param_str_.Swap(&other->param_str_); + std::swap(share_in_parallel_, other->share_in_parallel_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata PythonParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PythonParameter_descriptor_; + metadata.reflection = PythonParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// PythonParameter + +// optional string module = 1; +bool PythonParameter::has_module() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void PythonParameter::set_has_module() { + _has_bits_[0] |= 0x00000001u; +} +void PythonParameter::clear_has_module() { + _has_bits_[0] &= ~0x00000001u; +} +void PythonParameter::clear_module() { + module_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_module(); +} +const ::std::string& PythonParameter::module() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.module) + return module_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void PythonParameter::set_module(const ::std::string& value) { + set_has_module(); + module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.PythonParameter.module) +} +void PythonParameter::set_module(const char* value) { + set_has_module(); + module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.PythonParameter.module) +} +void PythonParameter::set_module(const char* value, size_t size) { + set_has_module(); + module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.PythonParameter.module) +} +::std::string* PythonParameter::mutable_module() { + set_has_module(); + // @@protoc_insertion_point(field_mutable:caffe.PythonParameter.module) + return module_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* PythonParameter::release_module() { + // @@protoc_insertion_point(field_release:caffe.PythonParameter.module) + clear_has_module(); + return module_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void PythonParameter::set_allocated_module(::std::string* module) { + if (module != NULL) { + set_has_module(); + } else { + clear_has_module(); + } + module_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), module); + // @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.module) +} + +// optional string layer = 2; +bool PythonParameter::has_layer() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void PythonParameter::set_has_layer() { + _has_bits_[0] |= 0x00000002u; +} +void PythonParameter::clear_has_layer() { + _has_bits_[0] &= ~0x00000002u; +} +void PythonParameter::clear_layer() { + layer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_layer(); +} +const ::std::string& PythonParameter::layer() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.layer) + return layer_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void PythonParameter::set_layer(const ::std::string& value) { + set_has_layer(); + layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.PythonParameter.layer) +} +void PythonParameter::set_layer(const char* value) { + set_has_layer(); + layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.PythonParameter.layer) +} +void PythonParameter::set_layer(const char* value, size_t size) { + set_has_layer(); + layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.PythonParameter.layer) +} +::std::string* PythonParameter::mutable_layer() { + set_has_layer(); + // @@protoc_insertion_point(field_mutable:caffe.PythonParameter.layer) + return layer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* PythonParameter::release_layer() { + // @@protoc_insertion_point(field_release:caffe.PythonParameter.layer) + clear_has_layer(); + return layer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void PythonParameter::set_allocated_layer(::std::string* layer) { + if (layer != NULL) { + set_has_layer(); + } else { + clear_has_layer(); + } + layer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), layer); + // @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.layer) +} + +// optional string param_str = 3 [default = ""]; +bool PythonParameter::has_param_str() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void PythonParameter::set_has_param_str() { + _has_bits_[0] |= 0x00000004u; +} +void PythonParameter::clear_has_param_str() { + _has_bits_[0] &= ~0x00000004u; +} +void PythonParameter::clear_param_str() { + param_str_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_param_str(); +} +const ::std::string& PythonParameter::param_str() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.param_str) + return param_str_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void PythonParameter::set_param_str(const ::std::string& value) { + set_has_param_str(); + param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.PythonParameter.param_str) +} +void PythonParameter::set_param_str(const char* value) { + set_has_param_str(); + param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.PythonParameter.param_str) +} +void PythonParameter::set_param_str(const char* value, size_t size) { + set_has_param_str(); + param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.PythonParameter.param_str) +} +::std::string* PythonParameter::mutable_param_str() { + set_has_param_str(); + // @@protoc_insertion_point(field_mutable:caffe.PythonParameter.param_str) + return param_str_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* PythonParameter::release_param_str() { + // @@protoc_insertion_point(field_release:caffe.PythonParameter.param_str) + clear_has_param_str(); + return param_str_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void PythonParameter::set_allocated_param_str(::std::string* param_str) { + if (param_str != NULL) { + set_has_param_str(); + } else { + clear_has_param_str(); + } + param_str_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), param_str); + // @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.param_str) +} + +// optional bool share_in_parallel = 4 [default = false]; +bool PythonParameter::has_share_in_parallel() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void PythonParameter::set_has_share_in_parallel() { + _has_bits_[0] |= 0x00000008u; +} +void PythonParameter::clear_has_share_in_parallel() { + _has_bits_[0] &= ~0x00000008u; +} +void PythonParameter::clear_share_in_parallel() { + share_in_parallel_ = false; + clear_has_share_in_parallel(); +} +bool PythonParameter::share_in_parallel() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.share_in_parallel) + return share_in_parallel_; +} +void PythonParameter::set_share_in_parallel(bool value) { + set_has_share_in_parallel(); + share_in_parallel_ = value; + // @@protoc_insertion_point(field_set:caffe.PythonParameter.share_in_parallel) +} + +inline const PythonParameter* PythonParameter::internal_default_instance() { + return &PythonParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RecurrentParameter::kNumOutputFieldNumber; +const int RecurrentParameter::kWeightFillerFieldNumber; +const int RecurrentParameter::kBiasFillerFieldNumber; +const int RecurrentParameter::kDebugInfoFieldNumber; +const int RecurrentParameter::kExposeHiddenFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RecurrentParameter::RecurrentParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.RecurrentParameter) +} + +void RecurrentParameter::InitAsDefaultInstance() { + weight_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); + bias_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +RecurrentParameter::RecurrentParameter(const RecurrentParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.RecurrentParameter) +} + +void RecurrentParameter::SharedCtor() { + _cached_size_ = 0; + weight_filler_ = NULL; + bias_filler_ = NULL; + ::memset(&num_output_, 0, reinterpret_cast(&expose_hidden_) - + reinterpret_cast(&num_output_) + sizeof(expose_hidden_)); +} + +RecurrentParameter::~RecurrentParameter() { + // @@protoc_insertion_point(destructor:caffe.RecurrentParameter) + SharedDtor(); +} + +void RecurrentParameter::SharedDtor() { + if (this != &RecurrentParameter_default_instance_.get()) { + delete weight_filler_; + delete bias_filler_; + } +} + +void RecurrentParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RecurrentParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RecurrentParameter_descriptor_; +} + +const RecurrentParameter& RecurrentParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed RecurrentParameter_default_instance_; + +RecurrentParameter* RecurrentParameter::New(::google::protobuf::Arena* arena) const { + RecurrentParameter* n = new RecurrentParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void RecurrentParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.RecurrentParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(RecurrentParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 31u) { + ZR_(num_output_, expose_hidden_); + if (has_weight_filler()) { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + } + if (has_bias_filler()) { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool RecurrentParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.RecurrentParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 num_output = 1 [default = 0]; + case 1: { + if (tag == 8) { + set_has_num_output(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &num_output_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_weight_filler; + break; + } + + // optional .caffe.FillerParameter weight_filler = 2; + case 2: { + if (tag == 18) { + parse_weight_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_weight_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_bias_filler; + break; + } + + // optional .caffe.FillerParameter bias_filler = 3; + case 3: { + if (tag == 26) { + parse_bias_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bias_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_debug_info; + break; + } + + // optional bool debug_info = 4 [default = false]; + case 4: { + if (tag == 32) { + parse_debug_info: + set_has_debug_info(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &debug_info_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_expose_hidden; + break; + } + + // optional bool expose_hidden = 5 [default = false]; + case 5: { + if (tag == 40) { + parse_expose_hidden: + set_has_expose_hidden(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &expose_hidden_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.RecurrentParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.RecurrentParameter) + return false; +#undef DO_ +} + +void RecurrentParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.RecurrentParameter) + // optional uint32 num_output = 1 [default = 0]; + if (has_num_output()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output); + } + + // optional .caffe.FillerParameter weight_filler = 2; + if (has_weight_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *this->weight_filler_, output); + } + + // optional .caffe.FillerParameter bias_filler = 3; + if (has_bias_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, *this->bias_filler_, output); + } + + // optional bool debug_info = 4 [default = false]; + if (has_debug_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->debug_info(), output); + } + + // optional bool expose_hidden = 5 [default = false]; + if (has_expose_hidden()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->expose_hidden(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.RecurrentParameter) +} + +::google::protobuf::uint8* RecurrentParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.RecurrentParameter) + // optional uint32 num_output = 1 [default = 0]; + if (has_num_output()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target); + } + + // optional .caffe.FillerParameter weight_filler = 2; + if (has_weight_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, *this->weight_filler_, false, target); + } + + // optional .caffe.FillerParameter bias_filler = 3; + if (has_bias_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 3, *this->bias_filler_, false, target); + } + + // optional bool debug_info = 4 [default = false]; + if (has_debug_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->debug_info(), target); + } + + // optional bool expose_hidden = 5 [default = false]; + if (has_expose_hidden()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->expose_hidden(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.RecurrentParameter) + return target; +} + +size_t RecurrentParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.RecurrentParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 31u) { + // optional uint32 num_output = 1 [default = 0]; + if (has_num_output()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->num_output()); + } + + // optional .caffe.FillerParameter weight_filler = 2; + if (has_weight_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->weight_filler_); + } + + // optional .caffe.FillerParameter bias_filler = 3; + if (has_bias_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->bias_filler_); + } + + // optional bool debug_info = 4 [default = false]; + if (has_debug_info()) { + total_size += 1 + 1; + } + + // optional bool expose_hidden = 5 [default = false]; + if (has_expose_hidden()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RecurrentParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.RecurrentParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const RecurrentParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.RecurrentParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.RecurrentParameter) + UnsafeMergeFrom(*source); + } +} + +void RecurrentParameter::MergeFrom(const RecurrentParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.RecurrentParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void RecurrentParameter::UnsafeMergeFrom(const RecurrentParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_num_output()) { + set_num_output(from.num_output()); + } + if (from.has_weight_filler()) { + mutable_weight_filler()->::caffe::FillerParameter::MergeFrom(from.weight_filler()); + } + if (from.has_bias_filler()) { + mutable_bias_filler()->::caffe::FillerParameter::MergeFrom(from.bias_filler()); + } + if (from.has_debug_info()) { + set_debug_info(from.debug_info()); + } + if (from.has_expose_hidden()) { + set_expose_hidden(from.expose_hidden()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void RecurrentParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.RecurrentParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RecurrentParameter::CopyFrom(const RecurrentParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.RecurrentParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool RecurrentParameter::IsInitialized() const { + + return true; +} + +void RecurrentParameter::Swap(RecurrentParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void RecurrentParameter::InternalSwap(RecurrentParameter* other) { + std::swap(num_output_, other->num_output_); + std::swap(weight_filler_, other->weight_filler_); + std::swap(bias_filler_, other->bias_filler_); + std::swap(debug_info_, other->debug_info_); + std::swap(expose_hidden_, other->expose_hidden_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata RecurrentParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RecurrentParameter_descriptor_; + metadata.reflection = RecurrentParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// RecurrentParameter + +// optional uint32 num_output = 1 [default = 0]; +bool RecurrentParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void RecurrentParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +void RecurrentParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +void RecurrentParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +::google::protobuf::uint32 RecurrentParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.num_output) + return num_output_; +} +void RecurrentParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.RecurrentParameter.num_output) +} + +// optional .caffe.FillerParameter weight_filler = 2; +bool RecurrentParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void RecurrentParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000002u; +} +void RecurrentParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000002u; +} +void RecurrentParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +const ::caffe::FillerParameter& RecurrentParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* RecurrentParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.RecurrentParameter.weight_filler) + return weight_filler_; +} +::caffe::FillerParameter* RecurrentParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.RecurrentParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +void RecurrentParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.RecurrentParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 3; +bool RecurrentParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void RecurrentParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000004u; +} +void RecurrentParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000004u; +} +void RecurrentParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +const ::caffe::FillerParameter& RecurrentParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* RecurrentParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.RecurrentParameter.bias_filler) + return bias_filler_; +} +::caffe::FillerParameter* RecurrentParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.RecurrentParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +void RecurrentParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.RecurrentParameter.bias_filler) +} + +// optional bool debug_info = 4 [default = false]; +bool RecurrentParameter::has_debug_info() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void RecurrentParameter::set_has_debug_info() { + _has_bits_[0] |= 0x00000008u; +} +void RecurrentParameter::clear_has_debug_info() { + _has_bits_[0] &= ~0x00000008u; +} +void RecurrentParameter::clear_debug_info() { + debug_info_ = false; + clear_has_debug_info(); +} +bool RecurrentParameter::debug_info() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.debug_info) + return debug_info_; +} +void RecurrentParameter::set_debug_info(bool value) { + set_has_debug_info(); + debug_info_ = value; + // @@protoc_insertion_point(field_set:caffe.RecurrentParameter.debug_info) +} + +// optional bool expose_hidden = 5 [default = false]; +bool RecurrentParameter::has_expose_hidden() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void RecurrentParameter::set_has_expose_hidden() { + _has_bits_[0] |= 0x00000010u; +} +void RecurrentParameter::clear_has_expose_hidden() { + _has_bits_[0] &= ~0x00000010u; +} +void RecurrentParameter::clear_expose_hidden() { + expose_hidden_ = false; + clear_has_expose_hidden(); +} +bool RecurrentParameter::expose_hidden() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.expose_hidden) + return expose_hidden_; +} +void RecurrentParameter::set_expose_hidden(bool value) { + set_has_expose_hidden(); + expose_hidden_ = value; + // @@protoc_insertion_point(field_set:caffe.RecurrentParameter.expose_hidden) +} + +inline const RecurrentParameter* RecurrentParameter::internal_default_instance() { + return &RecurrentParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* ReductionParameter_ReductionOp_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReductionParameter_ReductionOp_descriptor_; +} +bool ReductionParameter_ReductionOp_IsValid(int value) { + switch (value) { + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const ReductionParameter_ReductionOp ReductionParameter::SUM; +const ReductionParameter_ReductionOp ReductionParameter::ASUM; +const ReductionParameter_ReductionOp ReductionParameter::SUMSQ; +const ReductionParameter_ReductionOp ReductionParameter::MEAN; +const ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MIN; +const ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MAX; +const int ReductionParameter::ReductionOp_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ReductionParameter::kOperationFieldNumber; +const int ReductionParameter::kAxisFieldNumber; +const int ReductionParameter::kCoeffFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ReductionParameter::ReductionParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ReductionParameter) +} + +void ReductionParameter::InitAsDefaultInstance() { +} + +ReductionParameter::ReductionParameter(const ReductionParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ReductionParameter) +} + +void ReductionParameter::SharedCtor() { + _cached_size_ = 0; + axis_ = 0; + operation_ = 1; + coeff_ = 1; +} + +ReductionParameter::~ReductionParameter() { + // @@protoc_insertion_point(destructor:caffe.ReductionParameter) + SharedDtor(); +} + +void ReductionParameter::SharedDtor() { +} + +void ReductionParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ReductionParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReductionParameter_descriptor_; +} + +const ReductionParameter& ReductionParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ReductionParameter_default_instance_; + +ReductionParameter* ReductionParameter::New(::google::protobuf::Arena* arena) const { + ReductionParameter* n = new ReductionParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ReductionParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ReductionParameter) + if (_has_bits_[0 / 32] & 7u) { + operation_ = 1; + axis_ = 0; + coeff_ = 1; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ReductionParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ReductionParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::ReductionParameter_ReductionOp_IsValid(value)) { + set_operation(static_cast< ::caffe::ReductionParameter_ReductionOp >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_axis; + break; + } + + // optional int32 axis = 2 [default = 0]; + case 2: { + if (tag == 16) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_coeff; + break; + } + + // optional float coeff = 3 [default = 1]; + case 3: { + if (tag == 29) { + parse_coeff: + set_has_coeff(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &coeff_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ReductionParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ReductionParameter) + return false; +#undef DO_ +} + +void ReductionParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ReductionParameter) + // optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + if (has_operation()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->operation(), output); + } + + // optional int32 axis = 2 [default = 0]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output); + } + + // optional float coeff = 3 [default = 1]; + if (has_coeff()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->coeff(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ReductionParameter) +} + +::google::protobuf::uint8* ReductionParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ReductionParameter) + // optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + if (has_operation()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->operation(), target); + } + + // optional int32 axis = 2 [default = 0]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target); + } + + // optional float coeff = 3 [default = 1]; + if (has_coeff()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->coeff(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ReductionParameter) + return target; +} + +size_t ReductionParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ReductionParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + if (has_operation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation()); + } + + // optional int32 axis = 2 [default = 0]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional float coeff = 3 [default = 1]; + if (has_coeff()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ReductionParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ReductionParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ReductionParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ReductionParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ReductionParameter) + UnsafeMergeFrom(*source); + } +} + +void ReductionParameter::MergeFrom(const ReductionParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ReductionParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ReductionParameter::UnsafeMergeFrom(const ReductionParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_operation()) { + set_operation(from.operation()); + } + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_coeff()) { + set_coeff(from.coeff()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ReductionParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ReductionParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReductionParameter::CopyFrom(const ReductionParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ReductionParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ReductionParameter::IsInitialized() const { + + return true; +} + +void ReductionParameter::Swap(ReductionParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ReductionParameter::InternalSwap(ReductionParameter* other) { + std::swap(operation_, other->operation_); + std::swap(axis_, other->axis_); + std::swap(coeff_, other->coeff_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ReductionParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ReductionParameter_descriptor_; + metadata.reflection = ReductionParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ReductionParameter + +// optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; +bool ReductionParameter::has_operation() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ReductionParameter::set_has_operation() { + _has_bits_[0] |= 0x00000001u; +} +void ReductionParameter::clear_has_operation() { + _has_bits_[0] &= ~0x00000001u; +} +void ReductionParameter::clear_operation() { + operation_ = 1; + clear_has_operation(); +} +::caffe::ReductionParameter_ReductionOp ReductionParameter::operation() const { + // @@protoc_insertion_point(field_get:caffe.ReductionParameter.operation) + return static_cast< ::caffe::ReductionParameter_ReductionOp >(operation_); +} +void ReductionParameter::set_operation(::caffe::ReductionParameter_ReductionOp value) { + assert(::caffe::ReductionParameter_ReductionOp_IsValid(value)); + set_has_operation(); + operation_ = value; + // @@protoc_insertion_point(field_set:caffe.ReductionParameter.operation) +} + +// optional int32 axis = 2 [default = 0]; +bool ReductionParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ReductionParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +void ReductionParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +void ReductionParameter::clear_axis() { + axis_ = 0; + clear_has_axis(); +} +::google::protobuf::int32 ReductionParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ReductionParameter.axis) + return axis_; +} +void ReductionParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ReductionParameter.axis) +} + +// optional float coeff = 3 [default = 1]; +bool ReductionParameter::has_coeff() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void ReductionParameter::set_has_coeff() { + _has_bits_[0] |= 0x00000004u; +} +void ReductionParameter::clear_has_coeff() { + _has_bits_[0] &= ~0x00000004u; +} +void ReductionParameter::clear_coeff() { + coeff_ = 1; + clear_has_coeff(); +} +float ReductionParameter::coeff() const { + // @@protoc_insertion_point(field_get:caffe.ReductionParameter.coeff) + return coeff_; +} +void ReductionParameter::set_coeff(float value) { + set_has_coeff(); + coeff_ = value; + // @@protoc_insertion_point(field_set:caffe.ReductionParameter.coeff) +} + +inline const ReductionParameter* ReductionParameter::internal_default_instance() { + return &ReductionParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* ReLUParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReLUParameter_Engine_descriptor_; +} +bool ReLUParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const ReLUParameter_Engine ReLUParameter::DEFAULT; +const ReLUParameter_Engine ReLUParameter::CAFFE; +const ReLUParameter_Engine ReLUParameter::CUDNN; +const ReLUParameter_Engine ReLUParameter::Engine_MIN; +const ReLUParameter_Engine ReLUParameter::Engine_MAX; +const int ReLUParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ReLUParameter::kNegativeSlopeFieldNumber; +const int ReLUParameter::kEngineFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ReLUParameter::ReLUParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ReLUParameter) +} + +void ReLUParameter::InitAsDefaultInstance() { +} + +ReLUParameter::ReLUParameter(const ReLUParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ReLUParameter) +} + +void ReLUParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&negative_slope_, 0, reinterpret_cast(&engine_) - + reinterpret_cast(&negative_slope_) + sizeof(engine_)); +} + +ReLUParameter::~ReLUParameter() { + // @@protoc_insertion_point(destructor:caffe.ReLUParameter) + SharedDtor(); +} + +void ReLUParameter::SharedDtor() { +} + +void ReLUParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ReLUParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReLUParameter_descriptor_; +} + +const ReLUParameter& ReLUParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ReLUParameter_default_instance_; + +ReLUParameter* ReLUParameter::New(::google::protobuf::Arena* arena) const { + ReLUParameter* n = new ReLUParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ReLUParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ReLUParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(ReLUParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(negative_slope_, engine_); + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ReLUParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ReLUParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float negative_slope = 1 [default = 0]; + case 1: { + if (tag == 13) { + set_has_negative_slope(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &negative_slope_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_engine; + break; + } + + // optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + case 2: { + if (tag == 16) { + parse_engine: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::ReLUParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::ReLUParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ReLUParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ReLUParameter) + return false; +#undef DO_ +} + +void ReLUParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ReLUParameter) + // optional float negative_slope = 1 [default = 0]; + if (has_negative_slope()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->negative_slope(), output); + } + + // optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->engine(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ReLUParameter) +} + +::google::protobuf::uint8* ReLUParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ReLUParameter) + // optional float negative_slope = 1 [default = 0]; + if (has_negative_slope()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->negative_slope(), target); + } + + // optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->engine(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ReLUParameter) + return target; +} + +size_t ReLUParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ReLUParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional float negative_slope = 1 [default = 0]; + if (has_negative_slope()) { + total_size += 1 + 4; + } + + // optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ReLUParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ReLUParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ReLUParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ReLUParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ReLUParameter) + UnsafeMergeFrom(*source); + } +} + +void ReLUParameter::MergeFrom(const ReLUParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ReLUParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ReLUParameter::UnsafeMergeFrom(const ReLUParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_negative_slope()) { + set_negative_slope(from.negative_slope()); + } + if (from.has_engine()) { + set_engine(from.engine()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ReLUParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ReLUParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReLUParameter::CopyFrom(const ReLUParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ReLUParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ReLUParameter::IsInitialized() const { + + return true; +} + +void ReLUParameter::Swap(ReLUParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ReLUParameter::InternalSwap(ReLUParameter* other) { + std::swap(negative_slope_, other->negative_slope_); + std::swap(engine_, other->engine_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ReLUParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ReLUParameter_descriptor_; + metadata.reflection = ReLUParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ReLUParameter + +// optional float negative_slope = 1 [default = 0]; +bool ReLUParameter::has_negative_slope() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ReLUParameter::set_has_negative_slope() { + _has_bits_[0] |= 0x00000001u; +} +void ReLUParameter::clear_has_negative_slope() { + _has_bits_[0] &= ~0x00000001u; +} +void ReLUParameter::clear_negative_slope() { + negative_slope_ = 0; + clear_has_negative_slope(); +} +float ReLUParameter::negative_slope() const { + // @@protoc_insertion_point(field_get:caffe.ReLUParameter.negative_slope) + return negative_slope_; +} +void ReLUParameter::set_negative_slope(float value) { + set_has_negative_slope(); + negative_slope_ = value; + // @@protoc_insertion_point(field_set:caffe.ReLUParameter.negative_slope) +} + +// optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; +bool ReLUParameter::has_engine() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ReLUParameter::set_has_engine() { + _has_bits_[0] |= 0x00000002u; +} +void ReLUParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000002u; +} +void ReLUParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::ReLUParameter_Engine ReLUParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.ReLUParameter.engine) + return static_cast< ::caffe::ReLUParameter_Engine >(engine_); +} +void ReLUParameter::set_engine(::caffe::ReLUParameter_Engine value) { + assert(::caffe::ReLUParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.ReLUParameter.engine) +} + +inline const ReLUParameter* ReLUParameter::internal_default_instance() { + return &ReLUParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ReshapeParameter::kShapeFieldNumber; +const int ReshapeParameter::kAxisFieldNumber; +const int ReshapeParameter::kNumAxesFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ReshapeParameter::ReshapeParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ReshapeParameter) +} + +void ReshapeParameter::InitAsDefaultInstance() { + shape_ = const_cast< ::caffe::BlobShape*>( + ::caffe::BlobShape::internal_default_instance()); +} + +ReshapeParameter::ReshapeParameter(const ReshapeParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ReshapeParameter) +} + +void ReshapeParameter::SharedCtor() { + _cached_size_ = 0; + shape_ = NULL; + axis_ = 0; + num_axes_ = -1; +} + +ReshapeParameter::~ReshapeParameter() { + // @@protoc_insertion_point(destructor:caffe.ReshapeParameter) + SharedDtor(); +} + +void ReshapeParameter::SharedDtor() { + if (this != &ReshapeParameter_default_instance_.get()) { + delete shape_; + } +} + +void ReshapeParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ReshapeParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReshapeParameter_descriptor_; +} + +const ReshapeParameter& ReshapeParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ReshapeParameter_default_instance_; + +ReshapeParameter* ReshapeParameter::New(::google::protobuf::Arena* arena) const { + ReshapeParameter* n = new ReshapeParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ReshapeParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ReshapeParameter) + if (_has_bits_[0 / 32] & 7u) { + if (has_shape()) { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + } + axis_ = 0; + num_axes_ = -1; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ReshapeParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ReshapeParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.BlobShape shape = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_axis; + break; + } + + // optional int32 axis = 2 [default = 0]; + case 2: { + if (tag == 16) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_num_axes; + break; + } + + // optional int32 num_axes = 3 [default = -1]; + case 3: { + if (tag == 24) { + parse_num_axes: + set_has_num_axes(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &num_axes_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ReshapeParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ReshapeParameter) + return false; +#undef DO_ +} + +void ReshapeParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ReshapeParameter) + // optional .caffe.BlobShape shape = 1; + if (has_shape()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, *this->shape_, output); + } + + // optional int32 axis = 2 [default = 0]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output); + } + + // optional int32 num_axes = 3 [default = -1]; + if (has_num_axes()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->num_axes(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ReshapeParameter) +} + +::google::protobuf::uint8* ReshapeParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ReshapeParameter) + // optional .caffe.BlobShape shape = 1; + if (has_shape()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, *this->shape_, false, target); + } + + // optional int32 axis = 2 [default = 0]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target); + } + + // optional int32 num_axes = 3 [default = -1]; + if (has_num_axes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->num_axes(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ReshapeParameter) + return target; +} + +size_t ReshapeParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ReshapeParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional .caffe.BlobShape shape = 1; + if (has_shape()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->shape_); + } + + // optional int32 axis = 2 [default = 0]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional int32 num_axes = 3 [default = -1]; + if (has_num_axes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->num_axes()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ReshapeParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ReshapeParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ReshapeParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ReshapeParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ReshapeParameter) + UnsafeMergeFrom(*source); + } +} + +void ReshapeParameter::MergeFrom(const ReshapeParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ReshapeParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ReshapeParameter::UnsafeMergeFrom(const ReshapeParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_shape()) { + mutable_shape()->::caffe::BlobShape::MergeFrom(from.shape()); + } + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_num_axes()) { + set_num_axes(from.num_axes()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ReshapeParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ReshapeParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReshapeParameter::CopyFrom(const ReshapeParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ReshapeParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ReshapeParameter::IsInitialized() const { + + return true; +} + +void ReshapeParameter::Swap(ReshapeParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ReshapeParameter::InternalSwap(ReshapeParameter* other) { + std::swap(shape_, other->shape_); + std::swap(axis_, other->axis_); + std::swap(num_axes_, other->num_axes_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ReshapeParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ReshapeParameter_descriptor_; + metadata.reflection = ReshapeParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ReshapeParameter + +// optional .caffe.BlobShape shape = 1; +bool ReshapeParameter::has_shape() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ReshapeParameter::set_has_shape() { + _has_bits_[0] |= 0x00000001u; +} +void ReshapeParameter::clear_has_shape() { + _has_bits_[0] &= ~0x00000001u; +} +void ReshapeParameter::clear_shape() { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + clear_has_shape(); +} +const ::caffe::BlobShape& ReshapeParameter::shape() const { + // @@protoc_insertion_point(field_get:caffe.ReshapeParameter.shape) + return shape_ != NULL ? *shape_ + : *::caffe::BlobShape::internal_default_instance(); +} +::caffe::BlobShape* ReshapeParameter::mutable_shape() { + set_has_shape(); + if (shape_ == NULL) { + shape_ = new ::caffe::BlobShape; + } + // @@protoc_insertion_point(field_mutable:caffe.ReshapeParameter.shape) + return shape_; +} +::caffe::BlobShape* ReshapeParameter::release_shape() { + // @@protoc_insertion_point(field_release:caffe.ReshapeParameter.shape) + clear_has_shape(); + ::caffe::BlobShape* temp = shape_; + shape_ = NULL; + return temp; +} +void ReshapeParameter::set_allocated_shape(::caffe::BlobShape* shape) { + delete shape_; + shape_ = shape; + if (shape) { + set_has_shape(); + } else { + clear_has_shape(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ReshapeParameter.shape) +} + +// optional int32 axis = 2 [default = 0]; +bool ReshapeParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ReshapeParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +void ReshapeParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +void ReshapeParameter::clear_axis() { + axis_ = 0; + clear_has_axis(); +} +::google::protobuf::int32 ReshapeParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ReshapeParameter.axis) + return axis_; +} +void ReshapeParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ReshapeParameter.axis) +} + +// optional int32 num_axes = 3 [default = -1]; +bool ReshapeParameter::has_num_axes() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void ReshapeParameter::set_has_num_axes() { + _has_bits_[0] |= 0x00000004u; +} +void ReshapeParameter::clear_has_num_axes() { + _has_bits_[0] &= ~0x00000004u; +} +void ReshapeParameter::clear_num_axes() { + num_axes_ = -1; + clear_has_num_axes(); +} +::google::protobuf::int32 ReshapeParameter::num_axes() const { + // @@protoc_insertion_point(field_get:caffe.ReshapeParameter.num_axes) + return num_axes_; +} +void ReshapeParameter::set_num_axes(::google::protobuf::int32 value) { + set_has_num_axes(); + num_axes_ = value; + // @@protoc_insertion_point(field_set:caffe.ReshapeParameter.num_axes) +} + +inline const ReshapeParameter* ReshapeParameter::internal_default_instance() { + return &ReshapeParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ScaleParameter::kAxisFieldNumber; +const int ScaleParameter::kNumAxesFieldNumber; +const int ScaleParameter::kFillerFieldNumber; +const int ScaleParameter::kBiasTermFieldNumber; +const int ScaleParameter::kBiasFillerFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ScaleParameter::ScaleParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ScaleParameter) +} + +void ScaleParameter::InitAsDefaultInstance() { + filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); + bias_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +ScaleParameter::ScaleParameter(const ScaleParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ScaleParameter) +} + +void ScaleParameter::SharedCtor() { + _cached_size_ = 0; + filler_ = NULL; + bias_filler_ = NULL; + bias_term_ = false; + axis_ = 1; + num_axes_ = 1; +} + +ScaleParameter::~ScaleParameter() { + // @@protoc_insertion_point(destructor:caffe.ScaleParameter) + SharedDtor(); +} + +void ScaleParameter::SharedDtor() { + if (this != &ScaleParameter_default_instance_.get()) { + delete filler_; + delete bias_filler_; + } +} + +void ScaleParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ScaleParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ScaleParameter_descriptor_; +} + +const ScaleParameter& ScaleParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ScaleParameter_default_instance_; + +ScaleParameter* ScaleParameter::New(::google::protobuf::Arena* arena) const { + ScaleParameter* n = new ScaleParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ScaleParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ScaleParameter) + if (_has_bits_[0 / 32] & 31u) { + axis_ = 1; + num_axes_ = 1; + if (has_filler()) { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + } + bias_term_ = false; + if (has_bias_filler()) { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + } + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ScaleParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ScaleParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 axis = 1 [default = 1]; + case 1: { + if (tag == 8) { + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_num_axes; + break; + } + + // optional int32 num_axes = 2 [default = 1]; + case 2: { + if (tag == 16) { + parse_num_axes: + set_has_num_axes(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &num_axes_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_filler; + break; + } + + // optional .caffe.FillerParameter filler = 3; + case 3: { + if (tag == 26) { + parse_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_bias_term; + break; + } + + // optional bool bias_term = 4 [default = false]; + case 4: { + if (tag == 32) { + parse_bias_term: + set_has_bias_term(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &bias_term_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_bias_filler; + break; + } + + // optional .caffe.FillerParameter bias_filler = 5; + case 5: { + if (tag == 42) { + parse_bias_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bias_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ScaleParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ScaleParameter) + return false; +#undef DO_ +} + +void ScaleParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ScaleParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output); + } + + // optional int32 num_axes = 2 [default = 1]; + if (has_num_axes()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_axes(), output); + } + + // optional .caffe.FillerParameter filler = 3; + if (has_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, *this->filler_, output); + } + + // optional bool bias_term = 4 [default = false]; + if (has_bias_term()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->bias_term(), output); + } + + // optional .caffe.FillerParameter bias_filler = 5; + if (has_bias_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *this->bias_filler_, output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ScaleParameter) +} + +::google::protobuf::uint8* ScaleParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ScaleParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target); + } + + // optional int32 num_axes = 2 [default = 1]; + if (has_num_axes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_axes(), target); + } + + // optional .caffe.FillerParameter filler = 3; + if (has_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 3, *this->filler_, false, target); + } + + // optional bool bias_term = 4 [default = false]; + if (has_bias_term()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->bias_term(), target); + } + + // optional .caffe.FillerParameter bias_filler = 5; + if (has_bias_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *this->bias_filler_, false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ScaleParameter) + return target; +} + +size_t ScaleParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ScaleParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 31u) { + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional int32 num_axes = 2 [default = 1]; + if (has_num_axes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->num_axes()); + } + + // optional .caffe.FillerParameter filler = 3; + if (has_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->filler_); + } + + // optional bool bias_term = 4 [default = false]; + if (has_bias_term()) { + total_size += 1 + 1; + } + + // optional .caffe.FillerParameter bias_filler = 5; + if (has_bias_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->bias_filler_); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ScaleParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ScaleParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ScaleParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ScaleParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ScaleParameter) + UnsafeMergeFrom(*source); + } +} + +void ScaleParameter::MergeFrom(const ScaleParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ScaleParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ScaleParameter::UnsafeMergeFrom(const ScaleParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_num_axes()) { + set_num_axes(from.num_axes()); + } + if (from.has_filler()) { + mutable_filler()->::caffe::FillerParameter::MergeFrom(from.filler()); + } + if (from.has_bias_term()) { + set_bias_term(from.bias_term()); + } + if (from.has_bias_filler()) { + mutable_bias_filler()->::caffe::FillerParameter::MergeFrom(from.bias_filler()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ScaleParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ScaleParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ScaleParameter::CopyFrom(const ScaleParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ScaleParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ScaleParameter::IsInitialized() const { + + return true; +} + +void ScaleParameter::Swap(ScaleParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ScaleParameter::InternalSwap(ScaleParameter* other) { + std::swap(axis_, other->axis_); + std::swap(num_axes_, other->num_axes_); + std::swap(filler_, other->filler_); + std::swap(bias_term_, other->bias_term_); + std::swap(bias_filler_, other->bias_filler_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ScaleParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ScaleParameter_descriptor_; + metadata.reflection = ScaleParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ScaleParameter + +// optional int32 axis = 1 [default = 1]; +bool ScaleParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ScaleParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +void ScaleParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +void ScaleParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 ScaleParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.axis) + return axis_; +} +void ScaleParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ScaleParameter.axis) +} + +// optional int32 num_axes = 2 [default = 1]; +bool ScaleParameter::has_num_axes() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void ScaleParameter::set_has_num_axes() { + _has_bits_[0] |= 0x00000002u; +} +void ScaleParameter::clear_has_num_axes() { + _has_bits_[0] &= ~0x00000002u; +} +void ScaleParameter::clear_num_axes() { + num_axes_ = 1; + clear_has_num_axes(); +} +::google::protobuf::int32 ScaleParameter::num_axes() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.num_axes) + return num_axes_; +} +void ScaleParameter::set_num_axes(::google::protobuf::int32 value) { + set_has_num_axes(); + num_axes_ = value; + // @@protoc_insertion_point(field_set:caffe.ScaleParameter.num_axes) +} + +// optional .caffe.FillerParameter filler = 3; +bool ScaleParameter::has_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void ScaleParameter::set_has_filler() { + _has_bits_[0] |= 0x00000004u; +} +void ScaleParameter::clear_has_filler() { + _has_bits_[0] &= ~0x00000004u; +} +void ScaleParameter::clear_filler() { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + clear_has_filler(); +} +const ::caffe::FillerParameter& ScaleParameter::filler() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.filler) + return filler_ != NULL ? *filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* ScaleParameter::mutable_filler() { + set_has_filler(); + if (filler_ == NULL) { + filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ScaleParameter.filler) + return filler_; +} +::caffe::FillerParameter* ScaleParameter::release_filler() { + // @@protoc_insertion_point(field_release:caffe.ScaleParameter.filler) + clear_has_filler(); + ::caffe::FillerParameter* temp = filler_; + filler_ = NULL; + return temp; +} +void ScaleParameter::set_allocated_filler(::caffe::FillerParameter* filler) { + delete filler_; + filler_ = filler; + if (filler) { + set_has_filler(); + } else { + clear_has_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ScaleParameter.filler) +} + +// optional bool bias_term = 4 [default = false]; +bool ScaleParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void ScaleParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000008u; +} +void ScaleParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000008u; +} +void ScaleParameter::clear_bias_term() { + bias_term_ = false; + clear_has_bias_term(); +} +bool ScaleParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.bias_term) + return bias_term_; +} +void ScaleParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.ScaleParameter.bias_term) +} + +// optional .caffe.FillerParameter bias_filler = 5; +bool ScaleParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void ScaleParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000010u; +} +void ScaleParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000010u; +} +void ScaleParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +const ::caffe::FillerParameter& ScaleParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* ScaleParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ScaleParameter.bias_filler) + return bias_filler_; +} +::caffe::FillerParameter* ScaleParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.ScaleParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +void ScaleParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ScaleParameter.bias_filler) +} + +inline const ScaleParameter* ScaleParameter::internal_default_instance() { + return &ScaleParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* SigmoidParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SigmoidParameter_Engine_descriptor_; +} +bool SigmoidParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const SigmoidParameter_Engine SigmoidParameter::DEFAULT; +const SigmoidParameter_Engine SigmoidParameter::CAFFE; +const SigmoidParameter_Engine SigmoidParameter::CUDNN; +const SigmoidParameter_Engine SigmoidParameter::Engine_MIN; +const SigmoidParameter_Engine SigmoidParameter::Engine_MAX; +const int SigmoidParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int SigmoidParameter::kEngineFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +SigmoidParameter::SigmoidParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.SigmoidParameter) +} + +void SigmoidParameter::InitAsDefaultInstance() { +} + +SigmoidParameter::SigmoidParameter(const SigmoidParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.SigmoidParameter) +} + +void SigmoidParameter::SharedCtor() { + _cached_size_ = 0; + engine_ = 0; +} + +SigmoidParameter::~SigmoidParameter() { + // @@protoc_insertion_point(destructor:caffe.SigmoidParameter) + SharedDtor(); +} + +void SigmoidParameter::SharedDtor() { +} + +void SigmoidParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SigmoidParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SigmoidParameter_descriptor_; +} + +const SigmoidParameter& SigmoidParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed SigmoidParameter_default_instance_; + +SigmoidParameter* SigmoidParameter::New(::google::protobuf::Arena* arena) const { + SigmoidParameter* n = new SigmoidParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void SigmoidParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.SigmoidParameter) + engine_ = 0; + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool SigmoidParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.SigmoidParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::SigmoidParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::SigmoidParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.SigmoidParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.SigmoidParameter) + return false; +#undef DO_ +} + +void SigmoidParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.SigmoidParameter) + // optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->engine(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.SigmoidParameter) +} + +::google::protobuf::uint8* SigmoidParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.SigmoidParameter) + // optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->engine(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.SigmoidParameter) + return target; +} + +size_t SigmoidParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.SigmoidParameter) + size_t total_size = 0; + + // optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SigmoidParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.SigmoidParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const SigmoidParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.SigmoidParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.SigmoidParameter) + UnsafeMergeFrom(*source); + } +} + +void SigmoidParameter::MergeFrom(const SigmoidParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.SigmoidParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void SigmoidParameter::UnsafeMergeFrom(const SigmoidParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_engine()) { + set_engine(from.engine()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void SigmoidParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.SigmoidParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SigmoidParameter::CopyFrom(const SigmoidParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.SigmoidParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool SigmoidParameter::IsInitialized() const { + + return true; +} + +void SigmoidParameter::Swap(SigmoidParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void SigmoidParameter::InternalSwap(SigmoidParameter* other) { + std::swap(engine_, other->engine_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata SigmoidParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SigmoidParameter_descriptor_; + metadata.reflection = SigmoidParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// SigmoidParameter + +// optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; +bool SigmoidParameter::has_engine() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void SigmoidParameter::set_has_engine() { + _has_bits_[0] |= 0x00000001u; +} +void SigmoidParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000001u; +} +void SigmoidParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::SigmoidParameter_Engine SigmoidParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.SigmoidParameter.engine) + return static_cast< ::caffe::SigmoidParameter_Engine >(engine_); +} +void SigmoidParameter::set_engine(::caffe::SigmoidParameter_Engine value) { + assert(::caffe::SigmoidParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.SigmoidParameter.engine) +} + +inline const SigmoidParameter* SigmoidParameter::internal_default_instance() { + return &SigmoidParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int SliceParameter::kAxisFieldNumber; +const int SliceParameter::kSlicePointFieldNumber; +const int SliceParameter::kSliceDimFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +SliceParameter::SliceParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.SliceParameter) +} + +void SliceParameter::InitAsDefaultInstance() { +} + +SliceParameter::SliceParameter(const SliceParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.SliceParameter) +} + +void SliceParameter::SharedCtor() { + _cached_size_ = 0; + axis_ = 1; + slice_dim_ = 1u; +} + +SliceParameter::~SliceParameter() { + // @@protoc_insertion_point(destructor:caffe.SliceParameter) + SharedDtor(); +} + +void SliceParameter::SharedDtor() { +} + +void SliceParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SliceParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SliceParameter_descriptor_; +} + +const SliceParameter& SliceParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed SliceParameter_default_instance_; + +SliceParameter* SliceParameter::New(::google::protobuf::Arena* arena) const { + SliceParameter* n = new SliceParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void SliceParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.SliceParameter) + if (_has_bits_[0 / 32] & 5u) { + axis_ = 1; + slice_dim_ = 1u; + } + slice_point_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool SliceParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.SliceParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 slice_dim = 1 [default = 1]; + case 1: { + if (tag == 8) { + set_has_slice_dim(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &slice_dim_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_slice_point; + break; + } + + // repeated uint32 slice_point = 2; + case 2: { + if (tag == 16) { + parse_slice_point: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 16, input, this->mutable_slice_point()))); + } else if (tag == 18) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_slice_point()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_slice_point; + if (input->ExpectTag(24)) goto parse_axis; + break; + } + + // optional int32 axis = 3 [default = 1]; + case 3: { + if (tag == 24) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.SliceParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.SliceParameter) + return false; +#undef DO_ +} + +void SliceParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.SliceParameter) + // optional uint32 slice_dim = 1 [default = 1]; + if (has_slice_dim()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->slice_dim(), output); + } + + // repeated uint32 slice_point = 2; + for (int i = 0; i < this->slice_point_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 2, this->slice_point(i), output); + } + + // optional int32 axis = 3 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->axis(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.SliceParameter) +} + +::google::protobuf::uint8* SliceParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.SliceParameter) + // optional uint32 slice_dim = 1 [default = 1]; + if (has_slice_dim()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->slice_dim(), target); + } + + // repeated uint32 slice_point = 2; + for (int i = 0; i < this->slice_point_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(2, this->slice_point(i), target); + } + + // optional int32 axis = 3 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->axis(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.SliceParameter) + return target; +} + +size_t SliceParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.SliceParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 5u) { + // optional int32 axis = 3 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional uint32 slice_dim = 1 [default = 1]; + if (has_slice_dim()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->slice_dim()); + } + + } + // repeated uint32 slice_point = 2; + { + size_t data_size = 0; + unsigned int count = this->slice_point_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->slice_point(i)); + } + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->slice_point_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SliceParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.SliceParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const SliceParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.SliceParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.SliceParameter) + UnsafeMergeFrom(*source); + } +} + +void SliceParameter::MergeFrom(const SliceParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.SliceParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void SliceParameter::UnsafeMergeFrom(const SliceParameter& from) { + GOOGLE_DCHECK(&from != this); + slice_point_.UnsafeMergeFrom(from.slice_point_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_slice_dim()) { + set_slice_dim(from.slice_dim()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void SliceParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.SliceParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SliceParameter::CopyFrom(const SliceParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.SliceParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool SliceParameter::IsInitialized() const { + + return true; +} + +void SliceParameter::Swap(SliceParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void SliceParameter::InternalSwap(SliceParameter* other) { + std::swap(axis_, other->axis_); + slice_point_.UnsafeArenaSwap(&other->slice_point_); + std::swap(slice_dim_, other->slice_dim_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata SliceParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SliceParameter_descriptor_; + metadata.reflection = SliceParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// SliceParameter + +// optional int32 axis = 3 [default = 1]; +bool SliceParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void SliceParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +void SliceParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +void SliceParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 SliceParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.SliceParameter.axis) + return axis_; +} +void SliceParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.SliceParameter.axis) +} + +// repeated uint32 slice_point = 2; +int SliceParameter::slice_point_size() const { + return slice_point_.size(); +} +void SliceParameter::clear_slice_point() { + slice_point_.Clear(); +} +::google::protobuf::uint32 SliceParameter::slice_point(int index) const { + // @@protoc_insertion_point(field_get:caffe.SliceParameter.slice_point) + return slice_point_.Get(index); +} +void SliceParameter::set_slice_point(int index, ::google::protobuf::uint32 value) { + slice_point_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.SliceParameter.slice_point) +} +void SliceParameter::add_slice_point(::google::protobuf::uint32 value) { + slice_point_.Add(value); + // @@protoc_insertion_point(field_add:caffe.SliceParameter.slice_point) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +SliceParameter::slice_point() const { + // @@protoc_insertion_point(field_list:caffe.SliceParameter.slice_point) + return slice_point_; +} +::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +SliceParameter::mutable_slice_point() { + // @@protoc_insertion_point(field_mutable_list:caffe.SliceParameter.slice_point) + return &slice_point_; +} + +// optional uint32 slice_dim = 1 [default = 1]; +bool SliceParameter::has_slice_dim() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void SliceParameter::set_has_slice_dim() { + _has_bits_[0] |= 0x00000004u; +} +void SliceParameter::clear_has_slice_dim() { + _has_bits_[0] &= ~0x00000004u; +} +void SliceParameter::clear_slice_dim() { + slice_dim_ = 1u; + clear_has_slice_dim(); +} +::google::protobuf::uint32 SliceParameter::slice_dim() const { + // @@protoc_insertion_point(field_get:caffe.SliceParameter.slice_dim) + return slice_dim_; +} +void SliceParameter::set_slice_dim(::google::protobuf::uint32 value) { + set_has_slice_dim(); + slice_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.SliceParameter.slice_dim) +} + +inline const SliceParameter* SliceParameter::internal_default_instance() { + return &SliceParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* SoftmaxParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SoftmaxParameter_Engine_descriptor_; +} +bool SoftmaxParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const SoftmaxParameter_Engine SoftmaxParameter::DEFAULT; +const SoftmaxParameter_Engine SoftmaxParameter::CAFFE; +const SoftmaxParameter_Engine SoftmaxParameter::CUDNN; +const SoftmaxParameter_Engine SoftmaxParameter::Engine_MIN; +const SoftmaxParameter_Engine SoftmaxParameter::Engine_MAX; +const int SoftmaxParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int SoftmaxParameter::kEngineFieldNumber; +const int SoftmaxParameter::kAxisFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +SoftmaxParameter::SoftmaxParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.SoftmaxParameter) +} + +void SoftmaxParameter::InitAsDefaultInstance() { +} + +SoftmaxParameter::SoftmaxParameter(const SoftmaxParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.SoftmaxParameter) +} + +void SoftmaxParameter::SharedCtor() { + _cached_size_ = 0; + engine_ = 0; + axis_ = 1; +} + +SoftmaxParameter::~SoftmaxParameter() { + // @@protoc_insertion_point(destructor:caffe.SoftmaxParameter) + SharedDtor(); +} + +void SoftmaxParameter::SharedDtor() { +} + +void SoftmaxParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SoftmaxParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SoftmaxParameter_descriptor_; +} + +const SoftmaxParameter& SoftmaxParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed SoftmaxParameter_default_instance_; + +SoftmaxParameter* SoftmaxParameter::New(::google::protobuf::Arena* arena) const { + SoftmaxParameter* n = new SoftmaxParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void SoftmaxParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.SoftmaxParameter) + if (_has_bits_[0 / 32] & 3u) { + engine_ = 0; + axis_ = 1; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool SoftmaxParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.SoftmaxParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::SoftmaxParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::SoftmaxParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_axis; + break; + } + + // optional int32 axis = 2 [default = 1]; + case 2: { + if (tag == 16) { + parse_axis: + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.SoftmaxParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.SoftmaxParameter) + return false; +#undef DO_ +} + +void SoftmaxParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.SoftmaxParameter) + // optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->engine(), output); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.SoftmaxParameter) +} + +::google::protobuf::uint8* SoftmaxParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.SoftmaxParameter) + // optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->engine(), target); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.SoftmaxParameter) + return target; +} + +size_t SoftmaxParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.SoftmaxParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + // optional int32 axis = 2 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SoftmaxParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.SoftmaxParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const SoftmaxParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.SoftmaxParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.SoftmaxParameter) + UnsafeMergeFrom(*source); + } +} + +void SoftmaxParameter::MergeFrom(const SoftmaxParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.SoftmaxParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void SoftmaxParameter::UnsafeMergeFrom(const SoftmaxParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_engine()) { + set_engine(from.engine()); + } + if (from.has_axis()) { + set_axis(from.axis()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void SoftmaxParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.SoftmaxParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SoftmaxParameter::CopyFrom(const SoftmaxParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.SoftmaxParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool SoftmaxParameter::IsInitialized() const { + + return true; +} + +void SoftmaxParameter::Swap(SoftmaxParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void SoftmaxParameter::InternalSwap(SoftmaxParameter* other) { + std::swap(engine_, other->engine_); + std::swap(axis_, other->axis_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata SoftmaxParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SoftmaxParameter_descriptor_; + metadata.reflection = SoftmaxParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// SoftmaxParameter + +// optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; +bool SoftmaxParameter::has_engine() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void SoftmaxParameter::set_has_engine() { + _has_bits_[0] |= 0x00000001u; +} +void SoftmaxParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000001u; +} +void SoftmaxParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::SoftmaxParameter_Engine SoftmaxParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.SoftmaxParameter.engine) + return static_cast< ::caffe::SoftmaxParameter_Engine >(engine_); +} +void SoftmaxParameter::set_engine(::caffe::SoftmaxParameter_Engine value) { + assert(::caffe::SoftmaxParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.SoftmaxParameter.engine) +} + +// optional int32 axis = 2 [default = 1]; +bool SoftmaxParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void SoftmaxParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +void SoftmaxParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +void SoftmaxParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 SoftmaxParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.SoftmaxParameter.axis) + return axis_; +} +void SoftmaxParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.SoftmaxParameter.axis) +} + +inline const SoftmaxParameter* SoftmaxParameter::internal_default_instance() { + return &SoftmaxParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* TanHParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return TanHParameter_Engine_descriptor_; +} +bool TanHParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const TanHParameter_Engine TanHParameter::DEFAULT; +const TanHParameter_Engine TanHParameter::CAFFE; +const TanHParameter_Engine TanHParameter::CUDNN; +const TanHParameter_Engine TanHParameter::Engine_MIN; +const TanHParameter_Engine TanHParameter::Engine_MAX; +const int TanHParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TanHParameter::kEngineFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TanHParameter::TanHParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.TanHParameter) +} + +void TanHParameter::InitAsDefaultInstance() { +} + +TanHParameter::TanHParameter(const TanHParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.TanHParameter) +} + +void TanHParameter::SharedCtor() { + _cached_size_ = 0; + engine_ = 0; +} + +TanHParameter::~TanHParameter() { + // @@protoc_insertion_point(destructor:caffe.TanHParameter) + SharedDtor(); +} + +void TanHParameter::SharedDtor() { +} + +void TanHParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TanHParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TanHParameter_descriptor_; +} + +const TanHParameter& TanHParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed TanHParameter_default_instance_; + +TanHParameter* TanHParameter::New(::google::protobuf::Arena* arena) const { + TanHParameter* n = new TanHParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TanHParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.TanHParameter) + engine_ = 0; + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool TanHParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.TanHParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::TanHParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::TanHParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.TanHParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.TanHParameter) + return false; +#undef DO_ +} + +void TanHParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.TanHParameter) + // optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->engine(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.TanHParameter) +} + +::google::protobuf::uint8* TanHParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.TanHParameter) + // optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->engine(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.TanHParameter) + return target; +} + +size_t TanHParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.TanHParameter) + size_t total_size = 0; + + // optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TanHParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.TanHParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const TanHParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.TanHParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.TanHParameter) + UnsafeMergeFrom(*source); + } +} + +void TanHParameter::MergeFrom(const TanHParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.TanHParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void TanHParameter::UnsafeMergeFrom(const TanHParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_engine()) { + set_engine(from.engine()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void TanHParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.TanHParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TanHParameter::CopyFrom(const TanHParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.TanHParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool TanHParameter::IsInitialized() const { + + return true; +} + +void TanHParameter::Swap(TanHParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void TanHParameter::InternalSwap(TanHParameter* other) { + std::swap(engine_, other->engine_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TanHParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TanHParameter_descriptor_; + metadata.reflection = TanHParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// TanHParameter + +// optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; +bool TanHParameter::has_engine() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void TanHParameter::set_has_engine() { + _has_bits_[0] |= 0x00000001u; +} +void TanHParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000001u; +} +void TanHParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::TanHParameter_Engine TanHParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.TanHParameter.engine) + return static_cast< ::caffe::TanHParameter_Engine >(engine_); +} +void TanHParameter::set_engine(::caffe::TanHParameter_Engine value) { + assert(::caffe::TanHParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.TanHParameter.engine) +} + +inline const TanHParameter* TanHParameter::internal_default_instance() { + return &TanHParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TileParameter::kAxisFieldNumber; +const int TileParameter::kTilesFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TileParameter::TileParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.TileParameter) +} + +void TileParameter::InitAsDefaultInstance() { +} + +TileParameter::TileParameter(const TileParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.TileParameter) +} + +void TileParameter::SharedCtor() { + _cached_size_ = 0; + tiles_ = 0; + axis_ = 1; +} + +TileParameter::~TileParameter() { + // @@protoc_insertion_point(destructor:caffe.TileParameter) + SharedDtor(); +} + +void TileParameter::SharedDtor() { +} + +void TileParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TileParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TileParameter_descriptor_; +} + +const TileParameter& TileParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed TileParameter_default_instance_; + +TileParameter* TileParameter::New(::google::protobuf::Arena* arena) const { + TileParameter* n = new TileParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TileParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.TileParameter) + if (_has_bits_[0 / 32] & 3u) { + axis_ = 1; + tiles_ = 0; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool TileParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.TileParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 axis = 1 [default = 1]; + case 1: { + if (tag == 8) { + set_has_axis(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &axis_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_tiles; + break; + } + + // optional int32 tiles = 2; + case 2: { + if (tag == 16) { + parse_tiles: + set_has_tiles(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &tiles_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.TileParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.TileParameter) + return false; +#undef DO_ +} + +void TileParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.TileParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output); + } + + // optional int32 tiles = 2; + if (has_tiles()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->tiles(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.TileParameter) +} + +::google::protobuf::uint8* TileParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.TileParameter) + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target); + } + + // optional int32 tiles = 2; + if (has_tiles()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->tiles(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.TileParameter) + return target; +} + +size_t TileParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.TileParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional int32 axis = 1 [default = 1]; + if (has_axis()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->axis()); + } + + // optional int32 tiles = 2; + if (has_tiles()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->tiles()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TileParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.TileParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const TileParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.TileParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.TileParameter) + UnsafeMergeFrom(*source); + } +} + +void TileParameter::MergeFrom(const TileParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.TileParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void TileParameter::UnsafeMergeFrom(const TileParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_axis()) { + set_axis(from.axis()); + } + if (from.has_tiles()) { + set_tiles(from.tiles()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void TileParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.TileParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TileParameter::CopyFrom(const TileParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.TileParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool TileParameter::IsInitialized() const { + + return true; +} + +void TileParameter::Swap(TileParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void TileParameter::InternalSwap(TileParameter* other) { + std::swap(axis_, other->axis_); + std::swap(tiles_, other->tiles_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TileParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TileParameter_descriptor_; + metadata.reflection = TileParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// TileParameter + +// optional int32 axis = 1 [default = 1]; +bool TileParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void TileParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +void TileParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +void TileParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +::google::protobuf::int32 TileParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.TileParameter.axis) + return axis_; +} +void TileParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.TileParameter.axis) +} + +// optional int32 tiles = 2; +bool TileParameter::has_tiles() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void TileParameter::set_has_tiles() { + _has_bits_[0] |= 0x00000002u; +} +void TileParameter::clear_has_tiles() { + _has_bits_[0] &= ~0x00000002u; +} +void TileParameter::clear_tiles() { + tiles_ = 0; + clear_has_tiles(); +} +::google::protobuf::int32 TileParameter::tiles() const { + // @@protoc_insertion_point(field_get:caffe.TileParameter.tiles) + return tiles_; +} +void TileParameter::set_tiles(::google::protobuf::int32 value) { + set_has_tiles(); + tiles_ = value; + // @@protoc_insertion_point(field_set:caffe.TileParameter.tiles) +} + +inline const TileParameter* TileParameter::internal_default_instance() { + return &TileParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ThresholdParameter::kThresholdFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ThresholdParameter::ThresholdParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.ThresholdParameter) +} + +void ThresholdParameter::InitAsDefaultInstance() { +} + +ThresholdParameter::ThresholdParameter(const ThresholdParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.ThresholdParameter) +} + +void ThresholdParameter::SharedCtor() { + _cached_size_ = 0; + threshold_ = 0; +} + +ThresholdParameter::~ThresholdParameter() { + // @@protoc_insertion_point(destructor:caffe.ThresholdParameter) + SharedDtor(); +} + +void ThresholdParameter::SharedDtor() { +} + +void ThresholdParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ThresholdParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ThresholdParameter_descriptor_; +} + +const ThresholdParameter& ThresholdParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed ThresholdParameter_default_instance_; + +ThresholdParameter* ThresholdParameter::New(::google::protobuf::Arena* arena) const { + ThresholdParameter* n = new ThresholdParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ThresholdParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.ThresholdParameter) + threshold_ = 0; + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool ThresholdParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.ThresholdParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float threshold = 1 [default = 0]; + case 1: { + if (tag == 13) { + set_has_threshold(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &threshold_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.ThresholdParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.ThresholdParameter) + return false; +#undef DO_ +} + +void ThresholdParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.ThresholdParameter) + // optional float threshold = 1 [default = 0]; + if (has_threshold()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->threshold(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.ThresholdParameter) +} + +::google::protobuf::uint8* ThresholdParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.ThresholdParameter) + // optional float threshold = 1 [default = 0]; + if (has_threshold()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->threshold(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.ThresholdParameter) + return target; +} + +size_t ThresholdParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.ThresholdParameter) + size_t total_size = 0; + + // optional float threshold = 1 [default = 0]; + if (has_threshold()) { + total_size += 1 + 4; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ThresholdParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.ThresholdParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const ThresholdParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.ThresholdParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.ThresholdParameter) + UnsafeMergeFrom(*source); + } +} + +void ThresholdParameter::MergeFrom(const ThresholdParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.ThresholdParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void ThresholdParameter::UnsafeMergeFrom(const ThresholdParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_threshold()) { + set_threshold(from.threshold()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void ThresholdParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.ThresholdParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ThresholdParameter::CopyFrom(const ThresholdParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.ThresholdParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool ThresholdParameter::IsInitialized() const { + + return true; +} + +void ThresholdParameter::Swap(ThresholdParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void ThresholdParameter::InternalSwap(ThresholdParameter* other) { + std::swap(threshold_, other->threshold_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ThresholdParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ThresholdParameter_descriptor_; + metadata.reflection = ThresholdParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// ThresholdParameter + +// optional float threshold = 1 [default = 0]; +bool ThresholdParameter::has_threshold() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void ThresholdParameter::set_has_threshold() { + _has_bits_[0] |= 0x00000001u; +} +void ThresholdParameter::clear_has_threshold() { + _has_bits_[0] &= ~0x00000001u; +} +void ThresholdParameter::clear_threshold() { + threshold_ = 0; + clear_has_threshold(); +} +float ThresholdParameter::threshold() const { + // @@protoc_insertion_point(field_get:caffe.ThresholdParameter.threshold) + return threshold_; +} +void ThresholdParameter::set_threshold(float value) { + set_has_threshold(); + threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.ThresholdParameter.threshold) +} + +inline const ThresholdParameter* ThresholdParameter::internal_default_instance() { + return &ThresholdParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +::std::string* WindowDataParameter::_default_crop_mode_ = NULL; +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int WindowDataParameter::kSourceFieldNumber; +const int WindowDataParameter::kScaleFieldNumber; +const int WindowDataParameter::kMeanFileFieldNumber; +const int WindowDataParameter::kBatchSizeFieldNumber; +const int WindowDataParameter::kCropSizeFieldNumber; +const int WindowDataParameter::kMirrorFieldNumber; +const int WindowDataParameter::kFgThresholdFieldNumber; +const int WindowDataParameter::kBgThresholdFieldNumber; +const int WindowDataParameter::kFgFractionFieldNumber; +const int WindowDataParameter::kContextPadFieldNumber; +const int WindowDataParameter::kCropModeFieldNumber; +const int WindowDataParameter::kCacheImagesFieldNumber; +const int WindowDataParameter::kRootFolderFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +WindowDataParameter::WindowDataParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.WindowDataParameter) +} + +void WindowDataParameter::InitAsDefaultInstance() { +} + +WindowDataParameter::WindowDataParameter(const WindowDataParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.WindowDataParameter) +} + +void WindowDataParameter::SharedCtor() { + _cached_size_ = 0; + source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + crop_mode_.UnsafeSetDefault(_default_crop_mode_); + root_folder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&batch_size_, 0, reinterpret_cast(&context_pad_) - + reinterpret_cast(&batch_size_) + sizeof(context_pad_)); + scale_ = 1; + fg_threshold_ = 0.5f; + bg_threshold_ = 0.5f; + fg_fraction_ = 0.25f; +} + +WindowDataParameter::~WindowDataParameter() { + // @@protoc_insertion_point(destructor:caffe.WindowDataParameter) + SharedDtor(); +} + +void WindowDataParameter::SharedDtor() { + source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + crop_mode_.DestroyNoArena(_default_crop_mode_); + root_folder_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void WindowDataParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* WindowDataParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return WindowDataParameter_descriptor_; +} + +const WindowDataParameter& WindowDataParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed WindowDataParameter_default_instance_; + +WindowDataParameter* WindowDataParameter::New(::google::protobuf::Arena* arena) const { + WindowDataParameter* n = new WindowDataParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void WindowDataParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.WindowDataParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(WindowDataParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 255u) { + ZR_(batch_size_, mirror_); + if (has_source()) { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + scale_ = 1; + if (has_mean_file()) { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + fg_threshold_ = 0.5f; + bg_threshold_ = 0.5f; + } + if (_has_bits_[8 / 32] & 7936u) { + ZR_(cache_images_, context_pad_); + fg_fraction_ = 0.25f; + if (has_crop_mode()) { + crop_mode_.ClearToDefaultNoArena(_default_crop_mode_); + } + if (has_root_folder()) { + root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool WindowDataParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.WindowDataParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string source = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_source())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.WindowDataParameter.source"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_scale; + break; + } + + // optional float scale = 2 [default = 1]; + case 2: { + if (tag == 21) { + parse_scale: + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_mean_file; + break; + } + + // optional string mean_file = 3; + case 3: { + if (tag == 26) { + parse_mean_file: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_mean_file())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.WindowDataParameter.mean_file"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_batch_size; + break; + } + + // optional uint32 batch_size = 4; + case 4: { + if (tag == 32) { + parse_batch_size: + set_has_batch_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &batch_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_crop_size; + break; + } + + // optional uint32 crop_size = 5 [default = 0]; + case 5: { + if (tag == 40) { + parse_crop_size: + set_has_crop_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &crop_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_mirror; + break; + } + + // optional bool mirror = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_mirror: + set_has_mirror(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &mirror_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(61)) goto parse_fg_threshold; + break; + } + + // optional float fg_threshold = 7 [default = 0.5]; + case 7: { + if (tag == 61) { + parse_fg_threshold: + set_has_fg_threshold(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &fg_threshold_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(69)) goto parse_bg_threshold; + break; + } + + // optional float bg_threshold = 8 [default = 0.5]; + case 8: { + if (tag == 69) { + parse_bg_threshold: + set_has_bg_threshold(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &bg_threshold_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(77)) goto parse_fg_fraction; + break; + } + + // optional float fg_fraction = 9 [default = 0.25]; + case 9: { + if (tag == 77) { + parse_fg_fraction: + set_has_fg_fraction(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &fg_fraction_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_context_pad; + break; + } + + // optional uint32 context_pad = 10 [default = 0]; + case 10: { + if (tag == 80) { + parse_context_pad: + set_has_context_pad(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &context_pad_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(90)) goto parse_crop_mode; + break; + } + + // optional string crop_mode = 11 [default = "warp"]; + case 11: { + if (tag == 90) { + parse_crop_mode: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_crop_mode())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->crop_mode().data(), this->crop_mode().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.WindowDataParameter.crop_mode"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_cache_images; + break; + } + + // optional bool cache_images = 12 [default = false]; + case 12: { + if (tag == 96) { + parse_cache_images: + set_has_cache_images(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &cache_images_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(106)) goto parse_root_folder; + break; + } + + // optional string root_folder = 13 [default = ""]; + case 13: { + if (tag == 106) { + parse_root_folder: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_root_folder())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->root_folder().data(), this->root_folder().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.WindowDataParameter.root_folder"); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.WindowDataParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.WindowDataParameter) + return false; +#undef DO_ +} + +void WindowDataParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.WindowDataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.source"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->source(), output); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output); + } + + // optional string mean_file = 3; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.mean_file"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->mean_file(), output); + } + + // optional uint32 batch_size = 4; + if (has_batch_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->batch_size(), output); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->crop_size(), output); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->mirror(), output); + } + + // optional float fg_threshold = 7 [default = 0.5]; + if (has_fg_threshold()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->fg_threshold(), output); + } + + // optional float bg_threshold = 8 [default = 0.5]; + if (has_bg_threshold()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->bg_threshold(), output); + } + + // optional float fg_fraction = 9 [default = 0.25]; + if (has_fg_fraction()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->fg_fraction(), output); + } + + // optional uint32 context_pad = 10 [default = 0]; + if (has_context_pad()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->context_pad(), output); + } + + // optional string crop_mode = 11 [default = "warp"]; + if (has_crop_mode()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->crop_mode().data(), this->crop_mode().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.crop_mode"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 11, this->crop_mode(), output); + } + + // optional bool cache_images = 12 [default = false]; + if (has_cache_images()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->cache_images(), output); + } + + // optional string root_folder = 13 [default = ""]; + if (has_root_folder()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->root_folder().data(), this->root_folder().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.root_folder"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 13, this->root_folder(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.WindowDataParameter) +} + +::google::protobuf::uint8* WindowDataParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.WindowDataParameter) + // optional string source = 1; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.source"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->source(), target); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target); + } + + // optional string mean_file = 3; + if (has_mean_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->mean_file().data(), this->mean_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.mean_file"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->mean_file(), target); + } + + // optional uint32 batch_size = 4; + if (has_batch_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->batch_size(), target); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->crop_size(), target); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->mirror(), target); + } + + // optional float fg_threshold = 7 [default = 0.5]; + if (has_fg_threshold()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->fg_threshold(), target); + } + + // optional float bg_threshold = 8 [default = 0.5]; + if (has_bg_threshold()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->bg_threshold(), target); + } + + // optional float fg_fraction = 9 [default = 0.25]; + if (has_fg_fraction()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->fg_fraction(), target); + } + + // optional uint32 context_pad = 10 [default = 0]; + if (has_context_pad()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->context_pad(), target); + } + + // optional string crop_mode = 11 [default = "warp"]; + if (has_crop_mode()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->crop_mode().data(), this->crop_mode().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.crop_mode"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 11, this->crop_mode(), target); + } + + // optional bool cache_images = 12 [default = false]; + if (has_cache_images()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->cache_images(), target); + } + + // optional string root_folder = 13 [default = ""]; + if (has_root_folder()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->root_folder().data(), this->root_folder().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.WindowDataParameter.root_folder"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 13, this->root_folder(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.WindowDataParameter) + return target; +} + +size_t WindowDataParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.WindowDataParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional string source = 1; + if (has_source()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->source()); + } + + // optional float scale = 2 [default = 1]; + if (has_scale()) { + total_size += 1 + 4; + } + + // optional string mean_file = 3; + if (has_mean_file()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->mean_file()); + } + + // optional uint32 batch_size = 4; + if (has_batch_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->batch_size()); + } + + // optional uint32 crop_size = 5 [default = 0]; + if (has_crop_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->crop_size()); + } + + // optional bool mirror = 6 [default = false]; + if (has_mirror()) { + total_size += 1 + 1; + } + + // optional float fg_threshold = 7 [default = 0.5]; + if (has_fg_threshold()) { + total_size += 1 + 4; + } + + // optional float bg_threshold = 8 [default = 0.5]; + if (has_bg_threshold()) { + total_size += 1 + 4; + } + + } + if (_has_bits_[8 / 32] & 7936u) { + // optional float fg_fraction = 9 [default = 0.25]; + if (has_fg_fraction()) { + total_size += 1 + 4; + } + + // optional uint32 context_pad = 10 [default = 0]; + if (has_context_pad()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->context_pad()); + } + + // optional string crop_mode = 11 [default = "warp"]; + if (has_crop_mode()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->crop_mode()); + } + + // optional bool cache_images = 12 [default = false]; + if (has_cache_images()) { + total_size += 1 + 1; + } + + // optional string root_folder = 13 [default = ""]; + if (has_root_folder()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->root_folder()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void WindowDataParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.WindowDataParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const WindowDataParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.WindowDataParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.WindowDataParameter) + UnsafeMergeFrom(*source); + } +} + +void WindowDataParameter::MergeFrom(const WindowDataParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.WindowDataParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void WindowDataParameter::UnsafeMergeFrom(const WindowDataParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_source()) { + set_has_source(); + source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_); + } + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_mean_file()) { + set_has_mean_file(); + mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_); + } + if (from.has_batch_size()) { + set_batch_size(from.batch_size()); + } + if (from.has_crop_size()) { + set_crop_size(from.crop_size()); + } + if (from.has_mirror()) { + set_mirror(from.mirror()); + } + if (from.has_fg_threshold()) { + set_fg_threshold(from.fg_threshold()); + } + if (from.has_bg_threshold()) { + set_bg_threshold(from.bg_threshold()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_fg_fraction()) { + set_fg_fraction(from.fg_fraction()); + } + if (from.has_context_pad()) { + set_context_pad(from.context_pad()); + } + if (from.has_crop_mode()) { + set_has_crop_mode(); + crop_mode_.AssignWithDefault(_default_crop_mode_, from.crop_mode_); + } + if (from.has_cache_images()) { + set_cache_images(from.cache_images()); + } + if (from.has_root_folder()) { + set_has_root_folder(); + root_folder_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.root_folder_); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void WindowDataParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.WindowDataParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void WindowDataParameter::CopyFrom(const WindowDataParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.WindowDataParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool WindowDataParameter::IsInitialized() const { + + return true; +} + +void WindowDataParameter::Swap(WindowDataParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void WindowDataParameter::InternalSwap(WindowDataParameter* other) { + source_.Swap(&other->source_); + std::swap(scale_, other->scale_); + mean_file_.Swap(&other->mean_file_); + std::swap(batch_size_, other->batch_size_); + std::swap(crop_size_, other->crop_size_); + std::swap(mirror_, other->mirror_); + std::swap(fg_threshold_, other->fg_threshold_); + std::swap(bg_threshold_, other->bg_threshold_); + std::swap(fg_fraction_, other->fg_fraction_); + std::swap(context_pad_, other->context_pad_); + crop_mode_.Swap(&other->crop_mode_); + std::swap(cache_images_, other->cache_images_); + root_folder_.Swap(&other->root_folder_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata WindowDataParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = WindowDataParameter_descriptor_; + metadata.reflection = WindowDataParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// WindowDataParameter + +// optional string source = 1; +bool WindowDataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void WindowDataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +void WindowDataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +void WindowDataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +const ::std::string& WindowDataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void WindowDataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.source) +} +void WindowDataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.source) +} +void WindowDataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.source) +} +::std::string* WindowDataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* WindowDataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void WindowDataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.source) +} + +// optional float scale = 2 [default = 1]; +bool WindowDataParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void WindowDataParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +void WindowDataParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +void WindowDataParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float WindowDataParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.scale) + return scale_; +} +void WindowDataParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.scale) +} + +// optional string mean_file = 3; +bool WindowDataParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void WindowDataParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000004u; +} +void WindowDataParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000004u; +} +void WindowDataParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +const ::std::string& WindowDataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void WindowDataParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.mean_file) +} +void WindowDataParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.mean_file) +} +void WindowDataParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.mean_file) +} +::std::string* WindowDataParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* WindowDataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void WindowDataParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.mean_file) +} + +// optional uint32 batch_size = 4; +bool WindowDataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void WindowDataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000008u; +} +void WindowDataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000008u; +} +void WindowDataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +::google::protobuf::uint32 WindowDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.batch_size) + return batch_size_; +} +void WindowDataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.batch_size) +} + +// optional uint32 crop_size = 5 [default = 0]; +bool WindowDataParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void WindowDataParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000010u; +} +void WindowDataParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000010u; +} +void WindowDataParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +::google::protobuf::uint32 WindowDataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.crop_size) + return crop_size_; +} +void WindowDataParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +bool WindowDataParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void WindowDataParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000020u; +} +void WindowDataParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000020u; +} +void WindowDataParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +bool WindowDataParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.mirror) + return mirror_; +} +void WindowDataParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.mirror) +} + +// optional float fg_threshold = 7 [default = 0.5]; +bool WindowDataParameter::has_fg_threshold() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void WindowDataParameter::set_has_fg_threshold() { + _has_bits_[0] |= 0x00000040u; +} +void WindowDataParameter::clear_has_fg_threshold() { + _has_bits_[0] &= ~0x00000040u; +} +void WindowDataParameter::clear_fg_threshold() { + fg_threshold_ = 0.5f; + clear_has_fg_threshold(); +} +float WindowDataParameter::fg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.fg_threshold) + return fg_threshold_; +} +void WindowDataParameter::set_fg_threshold(float value) { + set_has_fg_threshold(); + fg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.fg_threshold) +} + +// optional float bg_threshold = 8 [default = 0.5]; +bool WindowDataParameter::has_bg_threshold() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void WindowDataParameter::set_has_bg_threshold() { + _has_bits_[0] |= 0x00000080u; +} +void WindowDataParameter::clear_has_bg_threshold() { + _has_bits_[0] &= ~0x00000080u; +} +void WindowDataParameter::clear_bg_threshold() { + bg_threshold_ = 0.5f; + clear_has_bg_threshold(); +} +float WindowDataParameter::bg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.bg_threshold) + return bg_threshold_; +} +void WindowDataParameter::set_bg_threshold(float value) { + set_has_bg_threshold(); + bg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.bg_threshold) +} + +// optional float fg_fraction = 9 [default = 0.25]; +bool WindowDataParameter::has_fg_fraction() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void WindowDataParameter::set_has_fg_fraction() { + _has_bits_[0] |= 0x00000100u; +} +void WindowDataParameter::clear_has_fg_fraction() { + _has_bits_[0] &= ~0x00000100u; +} +void WindowDataParameter::clear_fg_fraction() { + fg_fraction_ = 0.25f; + clear_has_fg_fraction(); +} +float WindowDataParameter::fg_fraction() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.fg_fraction) + return fg_fraction_; +} +void WindowDataParameter::set_fg_fraction(float value) { + set_has_fg_fraction(); + fg_fraction_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.fg_fraction) +} + +// optional uint32 context_pad = 10 [default = 0]; +bool WindowDataParameter::has_context_pad() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void WindowDataParameter::set_has_context_pad() { + _has_bits_[0] |= 0x00000200u; +} +void WindowDataParameter::clear_has_context_pad() { + _has_bits_[0] &= ~0x00000200u; +} +void WindowDataParameter::clear_context_pad() { + context_pad_ = 0u; + clear_has_context_pad(); +} +::google::protobuf::uint32 WindowDataParameter::context_pad() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.context_pad) + return context_pad_; +} +void WindowDataParameter::set_context_pad(::google::protobuf::uint32 value) { + set_has_context_pad(); + context_pad_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.context_pad) +} + +// optional string crop_mode = 11 [default = "warp"]; +bool WindowDataParameter::has_crop_mode() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +void WindowDataParameter::set_has_crop_mode() { + _has_bits_[0] |= 0x00000400u; +} +void WindowDataParameter::clear_has_crop_mode() { + _has_bits_[0] &= ~0x00000400u; +} +void WindowDataParameter::clear_crop_mode() { + crop_mode_.ClearToDefaultNoArena(_default_crop_mode_); + clear_has_crop_mode(); +} +const ::std::string& WindowDataParameter::crop_mode() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.crop_mode) + return crop_mode_.GetNoArena(_default_crop_mode_); +} +void WindowDataParameter::set_crop_mode(const ::std::string& value) { + set_has_crop_mode(); + crop_mode_.SetNoArena(_default_crop_mode_, value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.crop_mode) +} +void WindowDataParameter::set_crop_mode(const char* value) { + set_has_crop_mode(); + crop_mode_.SetNoArena(_default_crop_mode_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.crop_mode) +} +void WindowDataParameter::set_crop_mode(const char* value, size_t size) { + set_has_crop_mode(); + crop_mode_.SetNoArena(_default_crop_mode_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.crop_mode) +} +::std::string* WindowDataParameter::mutable_crop_mode() { + set_has_crop_mode(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.crop_mode) + return crop_mode_.MutableNoArena(_default_crop_mode_); +} +::std::string* WindowDataParameter::release_crop_mode() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.crop_mode) + clear_has_crop_mode(); + return crop_mode_.ReleaseNoArena(_default_crop_mode_); +} +void WindowDataParameter::set_allocated_crop_mode(::std::string* crop_mode) { + if (crop_mode != NULL) { + set_has_crop_mode(); + } else { + clear_has_crop_mode(); + } + crop_mode_.SetAllocatedNoArena(_default_crop_mode_, crop_mode); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.crop_mode) +} + +// optional bool cache_images = 12 [default = false]; +bool WindowDataParameter::has_cache_images() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void WindowDataParameter::set_has_cache_images() { + _has_bits_[0] |= 0x00000800u; +} +void WindowDataParameter::clear_has_cache_images() { + _has_bits_[0] &= ~0x00000800u; +} +void WindowDataParameter::clear_cache_images() { + cache_images_ = false; + clear_has_cache_images(); +} +bool WindowDataParameter::cache_images() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.cache_images) + return cache_images_; +} +void WindowDataParameter::set_cache_images(bool value) { + set_has_cache_images(); + cache_images_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.cache_images) +} + +// optional string root_folder = 13 [default = ""]; +bool WindowDataParameter::has_root_folder() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +void WindowDataParameter::set_has_root_folder() { + _has_bits_[0] |= 0x00001000u; +} +void WindowDataParameter::clear_has_root_folder() { + _has_bits_[0] &= ~0x00001000u; +} +void WindowDataParameter::clear_root_folder() { + root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_root_folder(); +} +const ::std::string& WindowDataParameter::root_folder() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.root_folder) + return root_folder_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void WindowDataParameter::set_root_folder(const ::std::string& value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.root_folder) +} +void WindowDataParameter::set_root_folder(const char* value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.root_folder) +} +void WindowDataParameter::set_root_folder(const char* value, size_t size) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.root_folder) +} +::std::string* WindowDataParameter::mutable_root_folder() { + set_has_root_folder(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.root_folder) + return root_folder_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* WindowDataParameter::release_root_folder() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.root_folder) + clear_has_root_folder(); + return root_folder_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void WindowDataParameter::set_allocated_root_folder(::std::string* root_folder) { + if (root_folder != NULL) { + set_has_root_folder(); + } else { + clear_has_root_folder(); + } + root_folder_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root_folder); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.root_folder) +} + +inline const WindowDataParameter* WindowDataParameter::internal_default_instance() { + return &WindowDataParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* SPPParameter_PoolMethod_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SPPParameter_PoolMethod_descriptor_; +} +bool SPPParameter_PoolMethod_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const SPPParameter_PoolMethod SPPParameter::MAX; +const SPPParameter_PoolMethod SPPParameter::AVE; +const SPPParameter_PoolMethod SPPParameter::STOCHASTIC; +const SPPParameter_PoolMethod SPPParameter::PoolMethod_MIN; +const SPPParameter_PoolMethod SPPParameter::PoolMethod_MAX; +const int SPPParameter::PoolMethod_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* SPPParameter_Engine_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SPPParameter_Engine_descriptor_; +} +bool SPPParameter_Engine_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const SPPParameter_Engine SPPParameter::DEFAULT; +const SPPParameter_Engine SPPParameter::CAFFE; +const SPPParameter_Engine SPPParameter::CUDNN; +const SPPParameter_Engine SPPParameter::Engine_MIN; +const SPPParameter_Engine SPPParameter::Engine_MAX; +const int SPPParameter::Engine_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int SPPParameter::kPyramidHeightFieldNumber; +const int SPPParameter::kPoolFieldNumber; +const int SPPParameter::kEngineFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +SPPParameter::SPPParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.SPPParameter) +} + +void SPPParameter::InitAsDefaultInstance() { +} + +SPPParameter::SPPParameter(const SPPParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.SPPParameter) +} + +void SPPParameter::SharedCtor() { + _cached_size_ = 0; + ::memset(&pyramid_height_, 0, reinterpret_cast(&engine_) - + reinterpret_cast(&pyramid_height_) + sizeof(engine_)); +} + +SPPParameter::~SPPParameter() { + // @@protoc_insertion_point(destructor:caffe.SPPParameter) + SharedDtor(); +} + +void SPPParameter::SharedDtor() { +} + +void SPPParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SPPParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SPPParameter_descriptor_; +} + +const SPPParameter& SPPParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed SPPParameter_default_instance_; + +SPPParameter* SPPParameter::New(::google::protobuf::Arena* arena) const { + SPPParameter* n = new SPPParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void SPPParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.SPPParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(SPPParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(pyramid_height_, engine_); + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool SPPParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.SPPParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional uint32 pyramid_height = 1; + case 1: { + if (tag == 8) { + set_has_pyramid_height(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &pyramid_height_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_pool; + break; + } + + // optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + case 2: { + if (tag == 16) { + parse_pool: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::SPPParameter_PoolMethod_IsValid(value)) { + set_pool(static_cast< ::caffe::SPPParameter_PoolMethod >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_engine; + break; + } + + // optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + case 6: { + if (tag == 48) { + parse_engine: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::SPPParameter_Engine_IsValid(value)) { + set_engine(static_cast< ::caffe::SPPParameter_Engine >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.SPPParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.SPPParameter) + return false; +#undef DO_ +} + +void SPPParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.SPPParameter) + // optional uint32 pyramid_height = 1; + if (has_pyramid_height()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->pyramid_height(), output); + } + + // optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + if (has_pool()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->pool(), output); + } + + // optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + if (has_engine()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->engine(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.SPPParameter) +} + +::google::protobuf::uint8* SPPParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.SPPParameter) + // optional uint32 pyramid_height = 1; + if (has_pyramid_height()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->pyramid_height(), target); + } + + // optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + if (has_pool()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->pool(), target); + } + + // optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + if (has_engine()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->engine(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.SPPParameter) + return target; +} + +size_t SPPParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.SPPParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 7u) { + // optional uint32 pyramid_height = 1; + if (has_pyramid_height()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->pyramid_height()); + } + + // optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + if (has_pool()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->pool()); + } + + // optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + if (has_engine()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine()); + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SPPParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.SPPParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const SPPParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.SPPParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.SPPParameter) + UnsafeMergeFrom(*source); + } +} + +void SPPParameter::MergeFrom(const SPPParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.SPPParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void SPPParameter::UnsafeMergeFrom(const SPPParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_pyramid_height()) { + set_pyramid_height(from.pyramid_height()); + } + if (from.has_pool()) { + set_pool(from.pool()); + } + if (from.has_engine()) { + set_engine(from.engine()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void SPPParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.SPPParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SPPParameter::CopyFrom(const SPPParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.SPPParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool SPPParameter::IsInitialized() const { + + return true; +} + +void SPPParameter::Swap(SPPParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void SPPParameter::InternalSwap(SPPParameter* other) { + std::swap(pyramid_height_, other->pyramid_height_); + std::swap(pool_, other->pool_); + std::swap(engine_, other->engine_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata SPPParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SPPParameter_descriptor_; + metadata.reflection = SPPParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// SPPParameter + +// optional uint32 pyramid_height = 1; +bool SPPParameter::has_pyramid_height() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void SPPParameter::set_has_pyramid_height() { + _has_bits_[0] |= 0x00000001u; +} +void SPPParameter::clear_has_pyramid_height() { + _has_bits_[0] &= ~0x00000001u; +} +void SPPParameter::clear_pyramid_height() { + pyramid_height_ = 0u; + clear_has_pyramid_height(); +} +::google::protobuf::uint32 SPPParameter::pyramid_height() const { + // @@protoc_insertion_point(field_get:caffe.SPPParameter.pyramid_height) + return pyramid_height_; +} +void SPPParameter::set_pyramid_height(::google::protobuf::uint32 value) { + set_has_pyramid_height(); + pyramid_height_ = value; + // @@protoc_insertion_point(field_set:caffe.SPPParameter.pyramid_height) +} + +// optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; +bool SPPParameter::has_pool() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void SPPParameter::set_has_pool() { + _has_bits_[0] |= 0x00000002u; +} +void SPPParameter::clear_has_pool() { + _has_bits_[0] &= ~0x00000002u; +} +void SPPParameter::clear_pool() { + pool_ = 0; + clear_has_pool(); +} +::caffe::SPPParameter_PoolMethod SPPParameter::pool() const { + // @@protoc_insertion_point(field_get:caffe.SPPParameter.pool) + return static_cast< ::caffe::SPPParameter_PoolMethod >(pool_); +} +void SPPParameter::set_pool(::caffe::SPPParameter_PoolMethod value) { + assert(::caffe::SPPParameter_PoolMethod_IsValid(value)); + set_has_pool(); + pool_ = value; + // @@protoc_insertion_point(field_set:caffe.SPPParameter.pool) +} + +// optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; +bool SPPParameter::has_engine() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void SPPParameter::set_has_engine() { + _has_bits_[0] |= 0x00000004u; +} +void SPPParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000004u; +} +void SPPParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +::caffe::SPPParameter_Engine SPPParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.SPPParameter.engine) + return static_cast< ::caffe::SPPParameter_Engine >(engine_); +} +void SPPParameter::set_engine(::caffe::SPPParameter_Engine value) { + assert(::caffe::SPPParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.SPPParameter.engine) +} + +inline const SPPParameter* SPPParameter::internal_default_instance() { + return &SPPParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* V1LayerParameter_LayerType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return V1LayerParameter_LayerType_descriptor_; +} +bool V1LayerParameter_LayerType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const V1LayerParameter_LayerType V1LayerParameter::NONE; +const V1LayerParameter_LayerType V1LayerParameter::ABSVAL; +const V1LayerParameter_LayerType V1LayerParameter::ACCURACY; +const V1LayerParameter_LayerType V1LayerParameter::ARGMAX; +const V1LayerParameter_LayerType V1LayerParameter::BNLL; +const V1LayerParameter_LayerType V1LayerParameter::CONCAT; +const V1LayerParameter_LayerType V1LayerParameter::CONTRASTIVE_LOSS; +const V1LayerParameter_LayerType V1LayerParameter::CONVOLUTION; +const V1LayerParameter_LayerType V1LayerParameter::DATA; +const V1LayerParameter_LayerType V1LayerParameter::DECONVOLUTION; +const V1LayerParameter_LayerType V1LayerParameter::DROPOUT; +const V1LayerParameter_LayerType V1LayerParameter::DUMMY_DATA; +const V1LayerParameter_LayerType V1LayerParameter::EUCLIDEAN_LOSS; +const V1LayerParameter_LayerType V1LayerParameter::ELTWISE; +const V1LayerParameter_LayerType V1LayerParameter::EXP; +const V1LayerParameter_LayerType V1LayerParameter::FLATTEN; +const V1LayerParameter_LayerType V1LayerParameter::HDF5_DATA; +const V1LayerParameter_LayerType V1LayerParameter::HDF5_OUTPUT; +const V1LayerParameter_LayerType V1LayerParameter::HINGE_LOSS; +const V1LayerParameter_LayerType V1LayerParameter::IM2COL; +const V1LayerParameter_LayerType V1LayerParameter::IMAGE_DATA; +const V1LayerParameter_LayerType V1LayerParameter::INFOGAIN_LOSS; +const V1LayerParameter_LayerType V1LayerParameter::INNER_PRODUCT; +const V1LayerParameter_LayerType V1LayerParameter::LRN; +const V1LayerParameter_LayerType V1LayerParameter::MEMORY_DATA; +const V1LayerParameter_LayerType V1LayerParameter::MULTINOMIAL_LOGISTIC_LOSS; +const V1LayerParameter_LayerType V1LayerParameter::MVN; +const V1LayerParameter_LayerType V1LayerParameter::POOLING; +const V1LayerParameter_LayerType V1LayerParameter::POWER; +const V1LayerParameter_LayerType V1LayerParameter::RELU; +const V1LayerParameter_LayerType V1LayerParameter::SIGMOID; +const V1LayerParameter_LayerType V1LayerParameter::SIGMOID_CROSS_ENTROPY_LOSS; +const V1LayerParameter_LayerType V1LayerParameter::SILENCE; +const V1LayerParameter_LayerType V1LayerParameter::SOFTMAX; +const V1LayerParameter_LayerType V1LayerParameter::SOFTMAX_LOSS; +const V1LayerParameter_LayerType V1LayerParameter::SPLIT; +const V1LayerParameter_LayerType V1LayerParameter::SLICE; +const V1LayerParameter_LayerType V1LayerParameter::TANH; +const V1LayerParameter_LayerType V1LayerParameter::WINDOW_DATA; +const V1LayerParameter_LayerType V1LayerParameter::THRESHOLD; +const V1LayerParameter_LayerType V1LayerParameter::LayerType_MIN; +const V1LayerParameter_LayerType V1LayerParameter::LayerType_MAX; +const int V1LayerParameter::LayerType_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor() { + protobuf_AssignDescriptorsOnce(); + return V1LayerParameter_DimCheckMode_descriptor_; +} +bool V1LayerParameter_DimCheckMode_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const V1LayerParameter_DimCheckMode V1LayerParameter::STRICT; +const V1LayerParameter_DimCheckMode V1LayerParameter::PERMISSIVE; +const V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MIN; +const V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MAX; +const int V1LayerParameter::DimCheckMode_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int V1LayerParameter::kBottomFieldNumber; +const int V1LayerParameter::kTopFieldNumber; +const int V1LayerParameter::kNameFieldNumber; +const int V1LayerParameter::kIncludeFieldNumber; +const int V1LayerParameter::kExcludeFieldNumber; +const int V1LayerParameter::kTypeFieldNumber; +const int V1LayerParameter::kBlobsFieldNumber; +const int V1LayerParameter::kParamFieldNumber; +const int V1LayerParameter::kBlobShareModeFieldNumber; +const int V1LayerParameter::kBlobsLrFieldNumber; +const int V1LayerParameter::kWeightDecayFieldNumber; +const int V1LayerParameter::kLossWeightFieldNumber; +const int V1LayerParameter::kAccuracyParamFieldNumber; +const int V1LayerParameter::kArgmaxParamFieldNumber; +const int V1LayerParameter::kConcatParamFieldNumber; +const int V1LayerParameter::kContrastiveLossParamFieldNumber; +const int V1LayerParameter::kConvolutionParamFieldNumber; +const int V1LayerParameter::kDataParamFieldNumber; +const int V1LayerParameter::kDropoutParamFieldNumber; +const int V1LayerParameter::kDummyDataParamFieldNumber; +const int V1LayerParameter::kEltwiseParamFieldNumber; +const int V1LayerParameter::kExpParamFieldNumber; +const int V1LayerParameter::kHdf5DataParamFieldNumber; +const int V1LayerParameter::kHdf5OutputParamFieldNumber; +const int V1LayerParameter::kHingeLossParamFieldNumber; +const int V1LayerParameter::kImageDataParamFieldNumber; +const int V1LayerParameter::kInfogainLossParamFieldNumber; +const int V1LayerParameter::kInnerProductParamFieldNumber; +const int V1LayerParameter::kLrnParamFieldNumber; +const int V1LayerParameter::kMemoryDataParamFieldNumber; +const int V1LayerParameter::kMvnParamFieldNumber; +const int V1LayerParameter::kPoolingParamFieldNumber; +const int V1LayerParameter::kPowerParamFieldNumber; +const int V1LayerParameter::kReluParamFieldNumber; +const int V1LayerParameter::kSigmoidParamFieldNumber; +const int V1LayerParameter::kSoftmaxParamFieldNumber; +const int V1LayerParameter::kSliceParamFieldNumber; +const int V1LayerParameter::kTanhParamFieldNumber; +const int V1LayerParameter::kThresholdParamFieldNumber; +const int V1LayerParameter::kWindowDataParamFieldNumber; +const int V1LayerParameter::kTransformParamFieldNumber; +const int V1LayerParameter::kLossParamFieldNumber; +const int V1LayerParameter::kLayerFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +V1LayerParameter::V1LayerParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.V1LayerParameter) +} + +void V1LayerParameter::InitAsDefaultInstance() { + accuracy_param_ = const_cast< ::caffe::AccuracyParameter*>( + ::caffe::AccuracyParameter::internal_default_instance()); + argmax_param_ = const_cast< ::caffe::ArgMaxParameter*>( + ::caffe::ArgMaxParameter::internal_default_instance()); + concat_param_ = const_cast< ::caffe::ConcatParameter*>( + ::caffe::ConcatParameter::internal_default_instance()); + contrastive_loss_param_ = const_cast< ::caffe::ContrastiveLossParameter*>( + ::caffe::ContrastiveLossParameter::internal_default_instance()); + convolution_param_ = const_cast< ::caffe::ConvolutionParameter*>( + ::caffe::ConvolutionParameter::internal_default_instance()); + data_param_ = const_cast< ::caffe::DataParameter*>( + ::caffe::DataParameter::internal_default_instance()); + dropout_param_ = const_cast< ::caffe::DropoutParameter*>( + ::caffe::DropoutParameter::internal_default_instance()); + dummy_data_param_ = const_cast< ::caffe::DummyDataParameter*>( + ::caffe::DummyDataParameter::internal_default_instance()); + eltwise_param_ = const_cast< ::caffe::EltwiseParameter*>( + ::caffe::EltwiseParameter::internal_default_instance()); + exp_param_ = const_cast< ::caffe::ExpParameter*>( + ::caffe::ExpParameter::internal_default_instance()); + hdf5_data_param_ = const_cast< ::caffe::HDF5DataParameter*>( + ::caffe::HDF5DataParameter::internal_default_instance()); + hdf5_output_param_ = const_cast< ::caffe::HDF5OutputParameter*>( + ::caffe::HDF5OutputParameter::internal_default_instance()); + hinge_loss_param_ = const_cast< ::caffe::HingeLossParameter*>( + ::caffe::HingeLossParameter::internal_default_instance()); + image_data_param_ = const_cast< ::caffe::ImageDataParameter*>( + ::caffe::ImageDataParameter::internal_default_instance()); + infogain_loss_param_ = const_cast< ::caffe::InfogainLossParameter*>( + ::caffe::InfogainLossParameter::internal_default_instance()); + inner_product_param_ = const_cast< ::caffe::InnerProductParameter*>( + ::caffe::InnerProductParameter::internal_default_instance()); + lrn_param_ = const_cast< ::caffe::LRNParameter*>( + ::caffe::LRNParameter::internal_default_instance()); + memory_data_param_ = const_cast< ::caffe::MemoryDataParameter*>( + ::caffe::MemoryDataParameter::internal_default_instance()); + mvn_param_ = const_cast< ::caffe::MVNParameter*>( + ::caffe::MVNParameter::internal_default_instance()); + pooling_param_ = const_cast< ::caffe::PoolingParameter*>( + ::caffe::PoolingParameter::internal_default_instance()); + power_param_ = const_cast< ::caffe::PowerParameter*>( + ::caffe::PowerParameter::internal_default_instance()); + relu_param_ = const_cast< ::caffe::ReLUParameter*>( + ::caffe::ReLUParameter::internal_default_instance()); + sigmoid_param_ = const_cast< ::caffe::SigmoidParameter*>( + ::caffe::SigmoidParameter::internal_default_instance()); + softmax_param_ = const_cast< ::caffe::SoftmaxParameter*>( + ::caffe::SoftmaxParameter::internal_default_instance()); + slice_param_ = const_cast< ::caffe::SliceParameter*>( + ::caffe::SliceParameter::internal_default_instance()); + tanh_param_ = const_cast< ::caffe::TanHParameter*>( + ::caffe::TanHParameter::internal_default_instance()); + threshold_param_ = const_cast< ::caffe::ThresholdParameter*>( + ::caffe::ThresholdParameter::internal_default_instance()); + window_data_param_ = const_cast< ::caffe::WindowDataParameter*>( + ::caffe::WindowDataParameter::internal_default_instance()); + transform_param_ = const_cast< ::caffe::TransformationParameter*>( + ::caffe::TransformationParameter::internal_default_instance()); + loss_param_ = const_cast< ::caffe::LossParameter*>( + ::caffe::LossParameter::internal_default_instance()); + layer_ = const_cast< ::caffe::V0LayerParameter*>( + ::caffe::V0LayerParameter::internal_default_instance()); +} + +V1LayerParameter::V1LayerParameter(const V1LayerParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.V1LayerParameter) +} + +void V1LayerParameter::SharedCtor() { + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + accuracy_param_ = NULL; + argmax_param_ = NULL; + concat_param_ = NULL; + contrastive_loss_param_ = NULL; + convolution_param_ = NULL; + data_param_ = NULL; + dropout_param_ = NULL; + dummy_data_param_ = NULL; + eltwise_param_ = NULL; + exp_param_ = NULL; + hdf5_data_param_ = NULL; + hdf5_output_param_ = NULL; + hinge_loss_param_ = NULL; + image_data_param_ = NULL; + infogain_loss_param_ = NULL; + inner_product_param_ = NULL; + lrn_param_ = NULL; + memory_data_param_ = NULL; + mvn_param_ = NULL; + pooling_param_ = NULL; + power_param_ = NULL; + relu_param_ = NULL; + sigmoid_param_ = NULL; + softmax_param_ = NULL; + slice_param_ = NULL; + tanh_param_ = NULL; + threshold_param_ = NULL; + window_data_param_ = NULL; + transform_param_ = NULL; + loss_param_ = NULL; + layer_ = NULL; + type_ = 0; + _cached_size_ = 0; +} + +V1LayerParameter::~V1LayerParameter() { + // @@protoc_insertion_point(destructor:caffe.V1LayerParameter) + SharedDtor(); +} + +void V1LayerParameter::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != &V1LayerParameter_default_instance_.get()) { + delete accuracy_param_; + delete argmax_param_; + delete concat_param_; + delete contrastive_loss_param_; + delete convolution_param_; + delete data_param_; + delete dropout_param_; + delete dummy_data_param_; + delete eltwise_param_; + delete exp_param_; + delete hdf5_data_param_; + delete hdf5_output_param_; + delete hinge_loss_param_; + delete image_data_param_; + delete infogain_loss_param_; + delete inner_product_param_; + delete lrn_param_; + delete memory_data_param_; + delete mvn_param_; + delete pooling_param_; + delete power_param_; + delete relu_param_; + delete sigmoid_param_; + delete softmax_param_; + delete slice_param_; + delete tanh_param_; + delete threshold_param_; + delete window_data_param_; + delete transform_param_; + delete loss_param_; + delete layer_; + } +} + +void V1LayerParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* V1LayerParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return V1LayerParameter_descriptor_; +} + +const V1LayerParameter& V1LayerParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed V1LayerParameter_default_instance_; + +V1LayerParameter* V1LayerParameter::New(::google::protobuf::Arena* arena) const { + V1LayerParameter* n = new V1LayerParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void V1LayerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.V1LayerParameter) + if (_has_bits_[0 / 32] & 36u) { + if (has_name()) { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + type_ = 0; + } + if (_has_bits_[8 / 32] & 61440u) { + if (has_accuracy_param()) { + if (accuracy_param_ != NULL) accuracy_param_->::caffe::AccuracyParameter::Clear(); + } + if (has_argmax_param()) { + if (argmax_param_ != NULL) argmax_param_->::caffe::ArgMaxParameter::Clear(); + } + if (has_concat_param()) { + if (concat_param_ != NULL) concat_param_->::caffe::ConcatParameter::Clear(); + } + if (has_contrastive_loss_param()) { + if (contrastive_loss_param_ != NULL) contrastive_loss_param_->::caffe::ContrastiveLossParameter::Clear(); + } + } + if (_has_bits_[16 / 32] & 16711680u) { + if (has_convolution_param()) { + if (convolution_param_ != NULL) convolution_param_->::caffe::ConvolutionParameter::Clear(); + } + if (has_data_param()) { + if (data_param_ != NULL) data_param_->::caffe::DataParameter::Clear(); + } + if (has_dropout_param()) { + if (dropout_param_ != NULL) dropout_param_->::caffe::DropoutParameter::Clear(); + } + if (has_dummy_data_param()) { + if (dummy_data_param_ != NULL) dummy_data_param_->::caffe::DummyDataParameter::Clear(); + } + if (has_eltwise_param()) { + if (eltwise_param_ != NULL) eltwise_param_->::caffe::EltwiseParameter::Clear(); + } + if (has_exp_param()) { + if (exp_param_ != NULL) exp_param_->::caffe::ExpParameter::Clear(); + } + if (has_hdf5_data_param()) { + if (hdf5_data_param_ != NULL) hdf5_data_param_->::caffe::HDF5DataParameter::Clear(); + } + if (has_hdf5_output_param()) { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + } + } + if (_has_bits_[24 / 32] & 4278190080u) { + if (has_hinge_loss_param()) { + if (hinge_loss_param_ != NULL) hinge_loss_param_->::caffe::HingeLossParameter::Clear(); + } + if (has_image_data_param()) { + if (image_data_param_ != NULL) image_data_param_->::caffe::ImageDataParameter::Clear(); + } + if (has_infogain_loss_param()) { + if (infogain_loss_param_ != NULL) infogain_loss_param_->::caffe::InfogainLossParameter::Clear(); + } + if (has_inner_product_param()) { + if (inner_product_param_ != NULL) inner_product_param_->::caffe::InnerProductParameter::Clear(); + } + if (has_lrn_param()) { + if (lrn_param_ != NULL) lrn_param_->::caffe::LRNParameter::Clear(); + } + if (has_memory_data_param()) { + if (memory_data_param_ != NULL) memory_data_param_->::caffe::MemoryDataParameter::Clear(); + } + if (has_mvn_param()) { + if (mvn_param_ != NULL) mvn_param_->::caffe::MVNParameter::Clear(); + } + if (has_pooling_param()) { + if (pooling_param_ != NULL) pooling_param_->::caffe::PoolingParameter::Clear(); + } + } + if (_has_bits_[32 / 32] & 255u) { + if (has_power_param()) { + if (power_param_ != NULL) power_param_->::caffe::PowerParameter::Clear(); + } + if (has_relu_param()) { + if (relu_param_ != NULL) relu_param_->::caffe::ReLUParameter::Clear(); + } + if (has_sigmoid_param()) { + if (sigmoid_param_ != NULL) sigmoid_param_->::caffe::SigmoidParameter::Clear(); + } + if (has_softmax_param()) { + if (softmax_param_ != NULL) softmax_param_->::caffe::SoftmaxParameter::Clear(); + } + if (has_slice_param()) { + if (slice_param_ != NULL) slice_param_->::caffe::SliceParameter::Clear(); + } + if (has_tanh_param()) { + if (tanh_param_ != NULL) tanh_param_->::caffe::TanHParameter::Clear(); + } + if (has_threshold_param()) { + if (threshold_param_ != NULL) threshold_param_->::caffe::ThresholdParameter::Clear(); + } + if (has_window_data_param()) { + if (window_data_param_ != NULL) window_data_param_->::caffe::WindowDataParameter::Clear(); + } + } + if (_has_bits_[40 / 32] & 1792u) { + if (has_transform_param()) { + if (transform_param_ != NULL) transform_param_->::caffe::TransformationParameter::Clear(); + } + if (has_loss_param()) { + if (loss_param_ != NULL) loss_param_->::caffe::LossParameter::Clear(); + } + if (has_layer()) { + if (layer_ != NULL) layer_->::caffe::V0LayerParameter::Clear(); + } + } + bottom_.Clear(); + top_.Clear(); + include_.Clear(); + exclude_.Clear(); + blobs_.Clear(); + param_.Clear(); + blob_share_mode_.Clear(); + blobs_lr_.Clear(); + weight_decay_.Clear(); + loss_weight_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool V1LayerParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.V1LayerParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.V0LayerParameter layer = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_layer())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_bottom; + break; + } + + // repeated string bottom = 2; + case 2: { + if (tag == 18) { + parse_bottom: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_bottom())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->bottom(this->bottom_size() - 1).data(), + this->bottom(this->bottom_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V1LayerParameter.bottom"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_bottom; + if (input->ExpectTag(26)) goto parse_top; + break; + } + + // repeated string top = 3; + case 3: { + if (tag == 26) { + parse_top: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_top())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->top(this->top_size() - 1).data(), + this->top(this->top_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V1LayerParameter.top"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_top; + if (input->ExpectTag(34)) goto parse_name; + break; + } + + // optional string name = 4; + case 4: { + if (tag == 34) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V1LayerParameter.name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_type; + break; + } + + // optional .caffe.V1LayerParameter.LayerType type = 5; + case 5: { + if (tag == 40) { + parse_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::V1LayerParameter_LayerType_IsValid(value)) { + set_type(static_cast< ::caffe::V1LayerParameter_LayerType >(value)); + } else { + mutable_unknown_fields()->AddVarint(5, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_blobs; + break; + } + + // repeated .caffe.BlobProto blobs = 6; + case 6: { + if (tag == 50) { + parse_blobs: + DO_(input->IncrementRecursionDepth()); + parse_loop_blobs: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_blobs())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_loop_blobs; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(61)) goto parse_blobs_lr; + break; + } + + // repeated float blobs_lr = 7; + case 7: { + if (tag == 61) { + parse_blobs_lr: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 61, input, this->mutable_blobs_lr()))); + } else if (tag == 58) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_blobs_lr()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(61)) goto parse_blobs_lr; + if (input->ExpectTag(69)) goto parse_weight_decay; + break; + } + + // repeated float weight_decay = 8; + case 8: { + if (tag == 69) { + parse_weight_decay: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 69, input, this->mutable_weight_decay()))); + } else if (tag == 66) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_weight_decay()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(69)) goto parse_weight_decay; + if (input->ExpectTag(74)) goto parse_concat_param; + break; + } + + // optional .caffe.ConcatParameter concat_param = 9; + case 9: { + if (tag == 74) { + parse_concat_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_concat_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_convolution_param; + break; + } + + // optional .caffe.ConvolutionParameter convolution_param = 10; + case 10: { + if (tag == 82) { + parse_convolution_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_convolution_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(90)) goto parse_data_param; + break; + } + + // optional .caffe.DataParameter data_param = 11; + case 11: { + if (tag == 90) { + parse_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(98)) goto parse_dropout_param; + break; + } + + // optional .caffe.DropoutParameter dropout_param = 12; + case 12: { + if (tag == 98) { + parse_dropout_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_dropout_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(106)) goto parse_hdf5_data_param; + break; + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 13; + case 13: { + if (tag == 106) { + parse_hdf5_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_hdf5_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(114)) goto parse_hdf5_output_param; + break; + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 14; + case 14: { + if (tag == 114) { + parse_hdf5_output_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_hdf5_output_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(122)) goto parse_image_data_param; + break; + } + + // optional .caffe.ImageDataParameter image_data_param = 15; + case 15: { + if (tag == 122) { + parse_image_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_image_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(130)) goto parse_infogain_loss_param; + break; + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 16; + case 16: { + if (tag == 130) { + parse_infogain_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_infogain_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(138)) goto parse_inner_product_param; + break; + } + + // optional .caffe.InnerProductParameter inner_product_param = 17; + case 17: { + if (tag == 138) { + parse_inner_product_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_inner_product_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(146)) goto parse_lrn_param; + break; + } + + // optional .caffe.LRNParameter lrn_param = 18; + case 18: { + if (tag == 146) { + parse_lrn_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_lrn_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(154)) goto parse_pooling_param; + break; + } + + // optional .caffe.PoolingParameter pooling_param = 19; + case 19: { + if (tag == 154) { + parse_pooling_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_pooling_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(162)) goto parse_window_data_param; + break; + } + + // optional .caffe.WindowDataParameter window_data_param = 20; + case 20: { + if (tag == 162) { + parse_window_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_window_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(170)) goto parse_power_param; + break; + } + + // optional .caffe.PowerParameter power_param = 21; + case 21: { + if (tag == 170) { + parse_power_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_power_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(178)) goto parse_memory_data_param; + break; + } + + // optional .caffe.MemoryDataParameter memory_data_param = 22; + case 22: { + if (tag == 178) { + parse_memory_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_memory_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(186)) goto parse_argmax_param; + break; + } + + // optional .caffe.ArgMaxParameter argmax_param = 23; + case 23: { + if (tag == 186) { + parse_argmax_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_argmax_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(194)) goto parse_eltwise_param; + break; + } + + // optional .caffe.EltwiseParameter eltwise_param = 24; + case 24: { + if (tag == 194) { + parse_eltwise_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_eltwise_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(202)) goto parse_threshold_param; + break; + } + + // optional .caffe.ThresholdParameter threshold_param = 25; + case 25: { + if (tag == 202) { + parse_threshold_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_threshold_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(210)) goto parse_dummy_data_param; + break; + } + + // optional .caffe.DummyDataParameter dummy_data_param = 26; + case 26: { + if (tag == 210) { + parse_dummy_data_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_dummy_data_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(218)) goto parse_accuracy_param; + break; + } + + // optional .caffe.AccuracyParameter accuracy_param = 27; + case 27: { + if (tag == 218) { + parse_accuracy_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_accuracy_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(234)) goto parse_hinge_loss_param; + break; + } + + // optional .caffe.HingeLossParameter hinge_loss_param = 29; + case 29: { + if (tag == 234) { + parse_hinge_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_hinge_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(242)) goto parse_relu_param; + break; + } + + // optional .caffe.ReLUParameter relu_param = 30; + case 30: { + if (tag == 242) { + parse_relu_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_relu_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(250)) goto parse_slice_param; + break; + } + + // optional .caffe.SliceParameter slice_param = 31; + case 31: { + if (tag == 250) { + parse_slice_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_slice_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(258)) goto parse_include; + break; + } + + // repeated .caffe.NetStateRule include = 32; + case 32: { + if (tag == 258) { + parse_include: + DO_(input->IncrementRecursionDepth()); + parse_loop_include: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_include())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(258)) goto parse_loop_include; + if (input->ExpectTag(266)) goto parse_loop_exclude; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .caffe.NetStateRule exclude = 33; + case 33: { + if (tag == 266) { + DO_(input->IncrementRecursionDepth()); + parse_loop_exclude: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_exclude())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(266)) goto parse_loop_exclude; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(274)) goto parse_mvn_param; + break; + } + + // optional .caffe.MVNParameter mvn_param = 34; + case 34: { + if (tag == 274) { + parse_mvn_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_mvn_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(285)) goto parse_loss_weight; + break; + } + + // repeated float loss_weight = 35; + case 35: { + if (tag == 285) { + parse_loss_weight: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 2, 285, input, this->mutable_loss_weight()))); + } else if (tag == 282) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_loss_weight()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(285)) goto parse_loss_weight; + if (input->ExpectTag(290)) goto parse_transform_param; + break; + } + + // optional .caffe.TransformationParameter transform_param = 36; + case 36: { + if (tag == 290) { + parse_transform_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_transform_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(298)) goto parse_tanh_param; + break; + } + + // optional .caffe.TanHParameter tanh_param = 37; + case 37: { + if (tag == 298) { + parse_tanh_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tanh_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(306)) goto parse_sigmoid_param; + break; + } + + // optional .caffe.SigmoidParameter sigmoid_param = 38; + case 38: { + if (tag == 306) { + parse_sigmoid_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_sigmoid_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(314)) goto parse_softmax_param; + break; + } + + // optional .caffe.SoftmaxParameter softmax_param = 39; + case 39: { + if (tag == 314) { + parse_softmax_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_softmax_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(322)) goto parse_contrastive_loss_param; + break; + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40; + case 40: { + if (tag == 322) { + parse_contrastive_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_contrastive_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(330)) goto parse_exp_param; + break; + } + + // optional .caffe.ExpParameter exp_param = 41; + case 41: { + if (tag == 330) { + parse_exp_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_exp_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(338)) goto parse_loss_param; + break; + } + + // optional .caffe.LossParameter loss_param = 42; + case 42: { + if (tag == 338) { + parse_loss_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_loss_param())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(8010)) goto parse_param; + break; + } + + // repeated string param = 1001; + case 1001: { + if (tag == 8010) { + parse_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_param())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->param(this->param_size() - 1).data(), + this->param(this->param_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V1LayerParameter.param"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(8010)) goto parse_param; + if (input->ExpectTag(8016)) goto parse_blob_share_mode; + break; + } + + // repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + case 1002: { + if (tag == 8016) { + parse_blob_share_mode: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::V1LayerParameter_DimCheckMode_IsValid(value)) { + add_blob_share_mode(static_cast< ::caffe::V1LayerParameter_DimCheckMode >(value)); + } else { + mutable_unknown_fields()->AddVarint(1002, value); + } + } else if (tag == 8018) { + DO_((::google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns( + input, + 1002, + ::caffe::V1LayerParameter_DimCheckMode_IsValid, + mutable_unknown_fields(), + this->mutable_blob_share_mode()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(8016)) goto parse_blob_share_mode; + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.V1LayerParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.V1LayerParameter) + return false; +#undef DO_ +} + +void V1LayerParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.V1LayerParameter) + // optional .caffe.V0LayerParameter layer = 1; + if (has_layer()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, *this->layer_, output); + } + + // repeated string bottom = 2; + for (int i = 0; i < this->bottom_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->bottom(i).data(), this->bottom(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.bottom"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->bottom(i), output); + } + + // repeated string top = 3; + for (int i = 0; i < this->top_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->top(i).data(), this->top(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.top"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->top(i), output); + } + + // optional string name = 4; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->name(), output); + } + + // optional .caffe.V1LayerParameter.LayerType type = 5; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 5, this->type(), output); + } + + // repeated .caffe.BlobProto blobs = 6; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->blobs(i), output); + } + + // repeated float blobs_lr = 7; + for (int i = 0; i < this->blobs_lr_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 7, this->blobs_lr(i), output); + } + + // repeated float weight_decay = 8; + for (int i = 0; i < this->weight_decay_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 8, this->weight_decay(i), output); + } + + // optional .caffe.ConcatParameter concat_param = 9; + if (has_concat_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 9, *this->concat_param_, output); + } + + // optional .caffe.ConvolutionParameter convolution_param = 10; + if (has_convolution_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, *this->convolution_param_, output); + } + + // optional .caffe.DataParameter data_param = 11; + if (has_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 11, *this->data_param_, output); + } + + // optional .caffe.DropoutParameter dropout_param = 12; + if (has_dropout_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 12, *this->dropout_param_, output); + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 13; + if (has_hdf5_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 13, *this->hdf5_data_param_, output); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 14; + if (has_hdf5_output_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 14, *this->hdf5_output_param_, output); + } + + // optional .caffe.ImageDataParameter image_data_param = 15; + if (has_image_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 15, *this->image_data_param_, output); + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 16; + if (has_infogain_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 16, *this->infogain_loss_param_, output); + } + + // optional .caffe.InnerProductParameter inner_product_param = 17; + if (has_inner_product_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 17, *this->inner_product_param_, output); + } + + // optional .caffe.LRNParameter lrn_param = 18; + if (has_lrn_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 18, *this->lrn_param_, output); + } + + // optional .caffe.PoolingParameter pooling_param = 19; + if (has_pooling_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 19, *this->pooling_param_, output); + } + + // optional .caffe.WindowDataParameter window_data_param = 20; + if (has_window_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 20, *this->window_data_param_, output); + } + + // optional .caffe.PowerParameter power_param = 21; + if (has_power_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 21, *this->power_param_, output); + } + + // optional .caffe.MemoryDataParameter memory_data_param = 22; + if (has_memory_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 22, *this->memory_data_param_, output); + } + + // optional .caffe.ArgMaxParameter argmax_param = 23; + if (has_argmax_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 23, *this->argmax_param_, output); + } + + // optional .caffe.EltwiseParameter eltwise_param = 24; + if (has_eltwise_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 24, *this->eltwise_param_, output); + } + + // optional .caffe.ThresholdParameter threshold_param = 25; + if (has_threshold_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 25, *this->threshold_param_, output); + } + + // optional .caffe.DummyDataParameter dummy_data_param = 26; + if (has_dummy_data_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 26, *this->dummy_data_param_, output); + } + + // optional .caffe.AccuracyParameter accuracy_param = 27; + if (has_accuracy_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 27, *this->accuracy_param_, output); + } + + // optional .caffe.HingeLossParameter hinge_loss_param = 29; + if (has_hinge_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 29, *this->hinge_loss_param_, output); + } + + // optional .caffe.ReLUParameter relu_param = 30; + if (has_relu_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 30, *this->relu_param_, output); + } + + // optional .caffe.SliceParameter slice_param = 31; + if (has_slice_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 31, *this->slice_param_, output); + } + + // repeated .caffe.NetStateRule include = 32; + for (unsigned int i = 0, n = this->include_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 32, this->include(i), output); + } + + // repeated .caffe.NetStateRule exclude = 33; + for (unsigned int i = 0, n = this->exclude_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 33, this->exclude(i), output); + } + + // optional .caffe.MVNParameter mvn_param = 34; + if (has_mvn_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 34, *this->mvn_param_, output); + } + + // repeated float loss_weight = 35; + for (int i = 0; i < this->loss_weight_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 35, this->loss_weight(i), output); + } + + // optional .caffe.TransformationParameter transform_param = 36; + if (has_transform_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 36, *this->transform_param_, output); + } + + // optional .caffe.TanHParameter tanh_param = 37; + if (has_tanh_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 37, *this->tanh_param_, output); + } + + // optional .caffe.SigmoidParameter sigmoid_param = 38; + if (has_sigmoid_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 38, *this->sigmoid_param_, output); + } + + // optional .caffe.SoftmaxParameter softmax_param = 39; + if (has_softmax_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 39, *this->softmax_param_, output); + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40; + if (has_contrastive_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 40, *this->contrastive_loss_param_, output); + } + + // optional .caffe.ExpParameter exp_param = 41; + if (has_exp_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 41, *this->exp_param_, output); + } + + // optional .caffe.LossParameter loss_param = 42; + if (has_loss_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 42, *this->loss_param_, output); + } + + // repeated string param = 1001; + for (int i = 0; i < this->param_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->param(i).data(), this->param(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.param"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1001, this->param(i), output); + } + + // repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + for (int i = 0; i < this->blob_share_mode_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1002, this->blob_share_mode(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.V1LayerParameter) +} + +::google::protobuf::uint8* V1LayerParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.V1LayerParameter) + // optional .caffe.V0LayerParameter layer = 1; + if (has_layer()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, *this->layer_, false, target); + } + + // repeated string bottom = 2; + for (int i = 0; i < this->bottom_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->bottom(i).data(), this->bottom(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.bottom"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(2, this->bottom(i), target); + } + + // repeated string top = 3; + for (int i = 0; i < this->top_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->top(i).data(), this->top(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.top"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->top(i), target); + } + + // optional string name = 4; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->name(), target); + } + + // optional .caffe.V1LayerParameter.LayerType type = 5; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 5, this->type(), target); + } + + // repeated .caffe.BlobProto blobs = 6; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 6, this->blobs(i), false, target); + } + + // repeated float blobs_lr = 7; + for (int i = 0; i < this->blobs_lr_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(7, this->blobs_lr(i), target); + } + + // repeated float weight_decay = 8; + for (int i = 0; i < this->weight_decay_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(8, this->weight_decay(i), target); + } + + // optional .caffe.ConcatParameter concat_param = 9; + if (has_concat_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 9, *this->concat_param_, false, target); + } + + // optional .caffe.ConvolutionParameter convolution_param = 10; + if (has_convolution_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 10, *this->convolution_param_, false, target); + } + + // optional .caffe.DataParameter data_param = 11; + if (has_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 11, *this->data_param_, false, target); + } + + // optional .caffe.DropoutParameter dropout_param = 12; + if (has_dropout_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 12, *this->dropout_param_, false, target); + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 13; + if (has_hdf5_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 13, *this->hdf5_data_param_, false, target); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 14; + if (has_hdf5_output_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 14, *this->hdf5_output_param_, false, target); + } + + // optional .caffe.ImageDataParameter image_data_param = 15; + if (has_image_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 15, *this->image_data_param_, false, target); + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 16; + if (has_infogain_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 16, *this->infogain_loss_param_, false, target); + } + + // optional .caffe.InnerProductParameter inner_product_param = 17; + if (has_inner_product_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 17, *this->inner_product_param_, false, target); + } + + // optional .caffe.LRNParameter lrn_param = 18; + if (has_lrn_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 18, *this->lrn_param_, false, target); + } + + // optional .caffe.PoolingParameter pooling_param = 19; + if (has_pooling_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 19, *this->pooling_param_, false, target); + } + + // optional .caffe.WindowDataParameter window_data_param = 20; + if (has_window_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 20, *this->window_data_param_, false, target); + } + + // optional .caffe.PowerParameter power_param = 21; + if (has_power_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 21, *this->power_param_, false, target); + } + + // optional .caffe.MemoryDataParameter memory_data_param = 22; + if (has_memory_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 22, *this->memory_data_param_, false, target); + } + + // optional .caffe.ArgMaxParameter argmax_param = 23; + if (has_argmax_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 23, *this->argmax_param_, false, target); + } + + // optional .caffe.EltwiseParameter eltwise_param = 24; + if (has_eltwise_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 24, *this->eltwise_param_, false, target); + } + + // optional .caffe.ThresholdParameter threshold_param = 25; + if (has_threshold_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 25, *this->threshold_param_, false, target); + } + + // optional .caffe.DummyDataParameter dummy_data_param = 26; + if (has_dummy_data_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 26, *this->dummy_data_param_, false, target); + } + + // optional .caffe.AccuracyParameter accuracy_param = 27; + if (has_accuracy_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 27, *this->accuracy_param_, false, target); + } + + // optional .caffe.HingeLossParameter hinge_loss_param = 29; + if (has_hinge_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 29, *this->hinge_loss_param_, false, target); + } + + // optional .caffe.ReLUParameter relu_param = 30; + if (has_relu_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 30, *this->relu_param_, false, target); + } + + // optional .caffe.SliceParameter slice_param = 31; + if (has_slice_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 31, *this->slice_param_, false, target); + } + + // repeated .caffe.NetStateRule include = 32; + for (unsigned int i = 0, n = this->include_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 32, this->include(i), false, target); + } + + // repeated .caffe.NetStateRule exclude = 33; + for (unsigned int i = 0, n = this->exclude_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 33, this->exclude(i), false, target); + } + + // optional .caffe.MVNParameter mvn_param = 34; + if (has_mvn_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 34, *this->mvn_param_, false, target); + } + + // repeated float loss_weight = 35; + for (int i = 0; i < this->loss_weight_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(35, this->loss_weight(i), target); + } + + // optional .caffe.TransformationParameter transform_param = 36; + if (has_transform_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 36, *this->transform_param_, false, target); + } + + // optional .caffe.TanHParameter tanh_param = 37; + if (has_tanh_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 37, *this->tanh_param_, false, target); + } + + // optional .caffe.SigmoidParameter sigmoid_param = 38; + if (has_sigmoid_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 38, *this->sigmoid_param_, false, target); + } + + // optional .caffe.SoftmaxParameter softmax_param = 39; + if (has_softmax_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 39, *this->softmax_param_, false, target); + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40; + if (has_contrastive_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 40, *this->contrastive_loss_param_, false, target); + } + + // optional .caffe.ExpParameter exp_param = 41; + if (has_exp_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 41, *this->exp_param_, false, target); + } + + // optional .caffe.LossParameter loss_param = 42; + if (has_loss_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 42, *this->loss_param_, false, target); + } + + // repeated string param = 1001; + for (int i = 0; i < this->param_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->param(i).data(), this->param(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V1LayerParameter.param"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1001, this->param(i), target); + } + + // repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + for (int i = 0; i < this->blob_share_mode_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1002, this->blob_share_mode(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.V1LayerParameter) + return target; +} + +size_t V1LayerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.V1LayerParameter) + size_t total_size = 0; + + if (_has_bits_[2 / 32] & 36u) { + // optional string name = 4; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional .caffe.V1LayerParameter.LayerType type = 5; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + } + if (_has_bits_[12 / 32] & 61440u) { + // optional .caffe.AccuracyParameter accuracy_param = 27; + if (has_accuracy_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->accuracy_param_); + } + + // optional .caffe.ArgMaxParameter argmax_param = 23; + if (has_argmax_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->argmax_param_); + } + + // optional .caffe.ConcatParameter concat_param = 9; + if (has_concat_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->concat_param_); + } + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40; + if (has_contrastive_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->contrastive_loss_param_); + } + + } + if (_has_bits_[16 / 32] & 16711680u) { + // optional .caffe.ConvolutionParameter convolution_param = 10; + if (has_convolution_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->convolution_param_); + } + + // optional .caffe.DataParameter data_param = 11; + if (has_data_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->data_param_); + } + + // optional .caffe.DropoutParameter dropout_param = 12; + if (has_dropout_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->dropout_param_); + } + + // optional .caffe.DummyDataParameter dummy_data_param = 26; + if (has_dummy_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->dummy_data_param_); + } + + // optional .caffe.EltwiseParameter eltwise_param = 24; + if (has_eltwise_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->eltwise_param_); + } + + // optional .caffe.ExpParameter exp_param = 41; + if (has_exp_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->exp_param_); + } + + // optional .caffe.HDF5DataParameter hdf5_data_param = 13; + if (has_hdf5_data_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->hdf5_data_param_); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 14; + if (has_hdf5_output_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->hdf5_output_param_); + } + + } + if (_has_bits_[24 / 32] & 4278190080u) { + // optional .caffe.HingeLossParameter hinge_loss_param = 29; + if (has_hinge_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->hinge_loss_param_); + } + + // optional .caffe.ImageDataParameter image_data_param = 15; + if (has_image_data_param()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->image_data_param_); + } + + // optional .caffe.InfogainLossParameter infogain_loss_param = 16; + if (has_infogain_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->infogain_loss_param_); + } + + // optional .caffe.InnerProductParameter inner_product_param = 17; + if (has_inner_product_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->inner_product_param_); + } + + // optional .caffe.LRNParameter lrn_param = 18; + if (has_lrn_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->lrn_param_); + } + + // optional .caffe.MemoryDataParameter memory_data_param = 22; + if (has_memory_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->memory_data_param_); + } + + // optional .caffe.MVNParameter mvn_param = 34; + if (has_mvn_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->mvn_param_); + } + + // optional .caffe.PoolingParameter pooling_param = 19; + if (has_pooling_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->pooling_param_); + } + + } + if (_has_bits_[32 / 32] & 255u) { + // optional .caffe.PowerParameter power_param = 21; + if (has_power_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->power_param_); + } + + // optional .caffe.ReLUParameter relu_param = 30; + if (has_relu_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->relu_param_); + } + + // optional .caffe.SigmoidParameter sigmoid_param = 38; + if (has_sigmoid_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->sigmoid_param_); + } + + // optional .caffe.SoftmaxParameter softmax_param = 39; + if (has_softmax_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->softmax_param_); + } + + // optional .caffe.SliceParameter slice_param = 31; + if (has_slice_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->slice_param_); + } + + // optional .caffe.TanHParameter tanh_param = 37; + if (has_tanh_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->tanh_param_); + } + + // optional .caffe.ThresholdParameter threshold_param = 25; + if (has_threshold_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->threshold_param_); + } + + // optional .caffe.WindowDataParameter window_data_param = 20; + if (has_window_data_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->window_data_param_); + } + + } + if (_has_bits_[40 / 32] & 1792u) { + // optional .caffe.TransformationParameter transform_param = 36; + if (has_transform_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->transform_param_); + } + + // optional .caffe.LossParameter loss_param = 42; + if (has_loss_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->loss_param_); + } + + // optional .caffe.V0LayerParameter layer = 1; + if (has_layer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->layer_); + } + + } + // repeated string bottom = 2; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->bottom_size()); + for (int i = 0; i < this->bottom_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->bottom(i)); + } + + // repeated string top = 3; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->top_size()); + for (int i = 0; i < this->top_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->top(i)); + } + + // repeated .caffe.NetStateRule include = 32; + { + unsigned int count = this->include_size(); + total_size += 2UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->include(i)); + } + } + + // repeated .caffe.NetStateRule exclude = 33; + { + unsigned int count = this->exclude_size(); + total_size += 2UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->exclude(i)); + } + } + + // repeated .caffe.BlobProto blobs = 6; + { + unsigned int count = this->blobs_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blobs(i)); + } + } + + // repeated string param = 1001; + total_size += 2 * + ::google::protobuf::internal::FromIntSize(this->param_size()); + for (int i = 0; i < this->param_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->param(i)); + } + + // repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + { + size_t data_size = 0; + unsigned int count = this->blob_share_mode_size();for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->blob_share_mode(i)); + } + total_size += (2UL * count) + data_size; + } + + // repeated float blobs_lr = 7; + { + size_t data_size = 0; + unsigned int count = this->blobs_lr_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->blobs_lr_size()); + total_size += data_size; + } + + // repeated float weight_decay = 8; + { + size_t data_size = 0; + unsigned int count = this->weight_decay_size(); + data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->weight_decay_size()); + total_size += data_size; + } + + // repeated float loss_weight = 35; + { + size_t data_size = 0; + unsigned int count = this->loss_weight_size(); + data_size = 4UL * count; + total_size += 2 * + ::google::protobuf::internal::FromIntSize(this->loss_weight_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void V1LayerParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.V1LayerParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const V1LayerParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.V1LayerParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.V1LayerParameter) + UnsafeMergeFrom(*source); + } +} + +void V1LayerParameter::MergeFrom(const V1LayerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.V1LayerParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void V1LayerParameter::UnsafeMergeFrom(const V1LayerParameter& from) { + GOOGLE_DCHECK(&from != this); + bottom_.UnsafeMergeFrom(from.bottom_); + top_.UnsafeMergeFrom(from.top_); + include_.MergeFrom(from.include_); + exclude_.MergeFrom(from.exclude_); + blobs_.MergeFrom(from.blobs_); + param_.UnsafeMergeFrom(from.param_); + blob_share_mode_.UnsafeMergeFrom(from.blob_share_mode_); + blobs_lr_.UnsafeMergeFrom(from.blobs_lr_); + weight_decay_.UnsafeMergeFrom(from.weight_decay_); + loss_weight_.UnsafeMergeFrom(from.loss_weight_); + if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) { + if (from.has_name()) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_type()) { + set_type(from.type()); + } + } + if (from._has_bits_[12 / 32] & (0xffu << (12 % 32))) { + if (from.has_accuracy_param()) { + mutable_accuracy_param()->::caffe::AccuracyParameter::MergeFrom(from.accuracy_param()); + } + if (from.has_argmax_param()) { + mutable_argmax_param()->::caffe::ArgMaxParameter::MergeFrom(from.argmax_param()); + } + if (from.has_concat_param()) { + mutable_concat_param()->::caffe::ConcatParameter::MergeFrom(from.concat_param()); + } + if (from.has_contrastive_loss_param()) { + mutable_contrastive_loss_param()->::caffe::ContrastiveLossParameter::MergeFrom(from.contrastive_loss_param()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from.has_convolution_param()) { + mutable_convolution_param()->::caffe::ConvolutionParameter::MergeFrom(from.convolution_param()); + } + if (from.has_data_param()) { + mutable_data_param()->::caffe::DataParameter::MergeFrom(from.data_param()); + } + if (from.has_dropout_param()) { + mutable_dropout_param()->::caffe::DropoutParameter::MergeFrom(from.dropout_param()); + } + if (from.has_dummy_data_param()) { + mutable_dummy_data_param()->::caffe::DummyDataParameter::MergeFrom(from.dummy_data_param()); + } + if (from.has_eltwise_param()) { + mutable_eltwise_param()->::caffe::EltwiseParameter::MergeFrom(from.eltwise_param()); + } + if (from.has_exp_param()) { + mutable_exp_param()->::caffe::ExpParameter::MergeFrom(from.exp_param()); + } + if (from.has_hdf5_data_param()) { + mutable_hdf5_data_param()->::caffe::HDF5DataParameter::MergeFrom(from.hdf5_data_param()); + } + if (from.has_hdf5_output_param()) { + mutable_hdf5_output_param()->::caffe::HDF5OutputParameter::MergeFrom(from.hdf5_output_param()); + } + } + if (from._has_bits_[24 / 32] & (0xffu << (24 % 32))) { + if (from.has_hinge_loss_param()) { + mutable_hinge_loss_param()->::caffe::HingeLossParameter::MergeFrom(from.hinge_loss_param()); + } + if (from.has_image_data_param()) { + mutable_image_data_param()->::caffe::ImageDataParameter::MergeFrom(from.image_data_param()); + } + if (from.has_infogain_loss_param()) { + mutable_infogain_loss_param()->::caffe::InfogainLossParameter::MergeFrom(from.infogain_loss_param()); + } + if (from.has_inner_product_param()) { + mutable_inner_product_param()->::caffe::InnerProductParameter::MergeFrom(from.inner_product_param()); + } + if (from.has_lrn_param()) { + mutable_lrn_param()->::caffe::LRNParameter::MergeFrom(from.lrn_param()); + } + if (from.has_memory_data_param()) { + mutable_memory_data_param()->::caffe::MemoryDataParameter::MergeFrom(from.memory_data_param()); + } + if (from.has_mvn_param()) { + mutable_mvn_param()->::caffe::MVNParameter::MergeFrom(from.mvn_param()); + } + if (from.has_pooling_param()) { + mutable_pooling_param()->::caffe::PoolingParameter::MergeFrom(from.pooling_param()); + } + } + if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) { + if (from.has_power_param()) { + mutable_power_param()->::caffe::PowerParameter::MergeFrom(from.power_param()); + } + if (from.has_relu_param()) { + mutable_relu_param()->::caffe::ReLUParameter::MergeFrom(from.relu_param()); + } + if (from.has_sigmoid_param()) { + mutable_sigmoid_param()->::caffe::SigmoidParameter::MergeFrom(from.sigmoid_param()); + } + if (from.has_softmax_param()) { + mutable_softmax_param()->::caffe::SoftmaxParameter::MergeFrom(from.softmax_param()); + } + if (from.has_slice_param()) { + mutable_slice_param()->::caffe::SliceParameter::MergeFrom(from.slice_param()); + } + if (from.has_tanh_param()) { + mutable_tanh_param()->::caffe::TanHParameter::MergeFrom(from.tanh_param()); + } + if (from.has_threshold_param()) { + mutable_threshold_param()->::caffe::ThresholdParameter::MergeFrom(from.threshold_param()); + } + if (from.has_window_data_param()) { + mutable_window_data_param()->::caffe::WindowDataParameter::MergeFrom(from.window_data_param()); + } + } + if (from._has_bits_[40 / 32] & (0xffu << (40 % 32))) { + if (from.has_transform_param()) { + mutable_transform_param()->::caffe::TransformationParameter::MergeFrom(from.transform_param()); + } + if (from.has_loss_param()) { + mutable_loss_param()->::caffe::LossParameter::MergeFrom(from.loss_param()); + } + if (from.has_layer()) { + mutable_layer()->::caffe::V0LayerParameter::MergeFrom(from.layer()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void V1LayerParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.V1LayerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void V1LayerParameter::CopyFrom(const V1LayerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.V1LayerParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool V1LayerParameter::IsInitialized() const { + + return true; +} + +void V1LayerParameter::Swap(V1LayerParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void V1LayerParameter::InternalSwap(V1LayerParameter* other) { + bottom_.UnsafeArenaSwap(&other->bottom_); + top_.UnsafeArenaSwap(&other->top_); + name_.Swap(&other->name_); + include_.UnsafeArenaSwap(&other->include_); + exclude_.UnsafeArenaSwap(&other->exclude_); + std::swap(type_, other->type_); + blobs_.UnsafeArenaSwap(&other->blobs_); + param_.UnsafeArenaSwap(&other->param_); + blob_share_mode_.UnsafeArenaSwap(&other->blob_share_mode_); + blobs_lr_.UnsafeArenaSwap(&other->blobs_lr_); + weight_decay_.UnsafeArenaSwap(&other->weight_decay_); + loss_weight_.UnsafeArenaSwap(&other->loss_weight_); + std::swap(accuracy_param_, other->accuracy_param_); + std::swap(argmax_param_, other->argmax_param_); + std::swap(concat_param_, other->concat_param_); + std::swap(contrastive_loss_param_, other->contrastive_loss_param_); + std::swap(convolution_param_, other->convolution_param_); + std::swap(data_param_, other->data_param_); + std::swap(dropout_param_, other->dropout_param_); + std::swap(dummy_data_param_, other->dummy_data_param_); + std::swap(eltwise_param_, other->eltwise_param_); + std::swap(exp_param_, other->exp_param_); + std::swap(hdf5_data_param_, other->hdf5_data_param_); + std::swap(hdf5_output_param_, other->hdf5_output_param_); + std::swap(hinge_loss_param_, other->hinge_loss_param_); + std::swap(image_data_param_, other->image_data_param_); + std::swap(infogain_loss_param_, other->infogain_loss_param_); + std::swap(inner_product_param_, other->inner_product_param_); + std::swap(lrn_param_, other->lrn_param_); + std::swap(memory_data_param_, other->memory_data_param_); + std::swap(mvn_param_, other->mvn_param_); + std::swap(pooling_param_, other->pooling_param_); + std::swap(power_param_, other->power_param_); + std::swap(relu_param_, other->relu_param_); + std::swap(sigmoid_param_, other->sigmoid_param_); + std::swap(softmax_param_, other->softmax_param_); + std::swap(slice_param_, other->slice_param_); + std::swap(tanh_param_, other->tanh_param_); + std::swap(threshold_param_, other->threshold_param_); + std::swap(window_data_param_, other->window_data_param_); + std::swap(transform_param_, other->transform_param_); + std::swap(loss_param_, other->loss_param_); + std::swap(layer_, other->layer_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_has_bits_[1], other->_has_bits_[1]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata V1LayerParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = V1LayerParameter_descriptor_; + metadata.reflection = V1LayerParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// V1LayerParameter + +// repeated string bottom = 2; +int V1LayerParameter::bottom_size() const { + return bottom_.size(); +} +void V1LayerParameter::clear_bottom() { + bottom_.Clear(); +} +const ::std::string& V1LayerParameter::bottom(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.bottom) + return bottom_.Get(index); +} +::std::string* V1LayerParameter::mutable_bottom(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.bottom) + return bottom_.Mutable(index); +} +void V1LayerParameter::set_bottom(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.bottom) + bottom_.Mutable(index)->assign(value); +} +void V1LayerParameter::set_bottom(int index, const char* value) { + bottom_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.bottom) +} +void V1LayerParameter::set_bottom(int index, const char* value, size_t size) { + bottom_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.bottom) +} +::std::string* V1LayerParameter::add_bottom() { + // @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.bottom) + return bottom_.Add(); +} +void V1LayerParameter::add_bottom(const ::std::string& value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.bottom) +} +void V1LayerParameter::add_bottom(const char* value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.bottom) +} +void V1LayerParameter::add_bottom(const char* value, size_t size) { + bottom_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.bottom) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +V1LayerParameter::bottom() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.bottom) + return bottom_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +V1LayerParameter::mutable_bottom() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.bottom) + return &bottom_; +} + +// repeated string top = 3; +int V1LayerParameter::top_size() const { + return top_.size(); +} +void V1LayerParameter::clear_top() { + top_.Clear(); +} +const ::std::string& V1LayerParameter::top(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.top) + return top_.Get(index); +} +::std::string* V1LayerParameter::mutable_top(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.top) + return top_.Mutable(index); +} +void V1LayerParameter::set_top(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.top) + top_.Mutable(index)->assign(value); +} +void V1LayerParameter::set_top(int index, const char* value) { + top_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.top) +} +void V1LayerParameter::set_top(int index, const char* value, size_t size) { + top_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.top) +} +::std::string* V1LayerParameter::add_top() { + // @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.top) + return top_.Add(); +} +void V1LayerParameter::add_top(const ::std::string& value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.top) +} +void V1LayerParameter::add_top(const char* value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.top) +} +void V1LayerParameter::add_top(const char* value, size_t size) { + top_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.top) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +V1LayerParameter::top() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.top) + return top_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +V1LayerParameter::mutable_top() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.top) + return &top_; +} + +// optional string name = 4; +bool V1LayerParameter::has_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void V1LayerParameter::set_has_name() { + _has_bits_[0] |= 0x00000004u; +} +void V1LayerParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000004u; +} +void V1LayerParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +const ::std::string& V1LayerParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V1LayerParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.name) +} +void V1LayerParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.name) +} +void V1LayerParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.name) +} +::std::string* V1LayerParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* V1LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V1LayerParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.name) +} + +// repeated .caffe.NetStateRule include = 32; +int V1LayerParameter::include_size() const { + return include_.size(); +} +void V1LayerParameter::clear_include() { + include_.Clear(); +} +const ::caffe::NetStateRule& V1LayerParameter::include(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.include) + return include_.Get(index); +} +::caffe::NetStateRule* V1LayerParameter::mutable_include(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.include) + return include_.Mutable(index); +} +::caffe::NetStateRule* V1LayerParameter::add_include() { + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.include) + return include_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +V1LayerParameter::mutable_include() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.include) + return &include_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +V1LayerParameter::include() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.include) + return include_; +} + +// repeated .caffe.NetStateRule exclude = 33; +int V1LayerParameter::exclude_size() const { + return exclude_.size(); +} +void V1LayerParameter::clear_exclude() { + exclude_.Clear(); +} +const ::caffe::NetStateRule& V1LayerParameter::exclude(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.exclude) + return exclude_.Get(index); +} +::caffe::NetStateRule* V1LayerParameter::mutable_exclude(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.exclude) + return exclude_.Mutable(index); +} +::caffe::NetStateRule* V1LayerParameter::add_exclude() { + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.exclude) + return exclude_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +V1LayerParameter::mutable_exclude() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.exclude) + return &exclude_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +V1LayerParameter::exclude() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.exclude) + return exclude_; +} + +// optional .caffe.V1LayerParameter.LayerType type = 5; +bool V1LayerParameter::has_type() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void V1LayerParameter::set_has_type() { + _has_bits_[0] |= 0x00000020u; +} +void V1LayerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000020u; +} +void V1LayerParameter::clear_type() { + type_ = 0; + clear_has_type(); +} +::caffe::V1LayerParameter_LayerType V1LayerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.type) + return static_cast< ::caffe::V1LayerParameter_LayerType >(type_); +} +void V1LayerParameter::set_type(::caffe::V1LayerParameter_LayerType value) { + assert(::caffe::V1LayerParameter_LayerType_IsValid(value)); + set_has_type(); + type_ = value; + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.type) +} + +// repeated .caffe.BlobProto blobs = 6; +int V1LayerParameter::blobs_size() const { + return blobs_.size(); +} +void V1LayerParameter::clear_blobs() { + blobs_.Clear(); +} +const ::caffe::BlobProto& V1LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blobs) + return blobs_.Get(index); +} +::caffe::BlobProto* V1LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.blobs) + return blobs_.Mutable(index); +} +::caffe::BlobProto* V1LayerParameter::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blobs) + return blobs_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +V1LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blobs) + return &blobs_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +V1LayerParameter::blobs() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blobs) + return blobs_; +} + +// repeated string param = 1001; +int V1LayerParameter::param_size() const { + return param_.size(); +} +void V1LayerParameter::clear_param() { + param_.Clear(); +} +const ::std::string& V1LayerParameter::param(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.param) + return param_.Get(index); +} +::std::string* V1LayerParameter::mutable_param(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.param) + return param_.Mutable(index); +} +void V1LayerParameter::set_param(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.param) + param_.Mutable(index)->assign(value); +} +void V1LayerParameter::set_param(int index, const char* value) { + param_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.param) +} +void V1LayerParameter::set_param(int index, const char* value, size_t size) { + param_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.param) +} +::std::string* V1LayerParameter::add_param() { + // @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.param) + return param_.Add(); +} +void V1LayerParameter::add_param(const ::std::string& value) { + param_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.param) +} +void V1LayerParameter::add_param(const char* value) { + param_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.param) +} +void V1LayerParameter::add_param(const char* value, size_t size) { + param_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.param) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +V1LayerParameter::param() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.param) + return param_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +V1LayerParameter::mutable_param() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.param) + return ¶m_; +} + +// repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; +int V1LayerParameter::blob_share_mode_size() const { + return blob_share_mode_.size(); +} +void V1LayerParameter::clear_blob_share_mode() { + blob_share_mode_.Clear(); +} +::caffe::V1LayerParameter_DimCheckMode V1LayerParameter::blob_share_mode(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blob_share_mode) + return static_cast< ::caffe::V1LayerParameter_DimCheckMode >(blob_share_mode_.Get(index)); +} +void V1LayerParameter::set_blob_share_mode(int index, ::caffe::V1LayerParameter_DimCheckMode value) { + assert(::caffe::V1LayerParameter_DimCheckMode_IsValid(value)); + blob_share_mode_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.blob_share_mode) +} +void V1LayerParameter::add_blob_share_mode(::caffe::V1LayerParameter_DimCheckMode value) { + assert(::caffe::V1LayerParameter_DimCheckMode_IsValid(value)); + blob_share_mode_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blob_share_mode) +} +const ::google::protobuf::RepeatedField& +V1LayerParameter::blob_share_mode() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blob_share_mode) + return blob_share_mode_; +} +::google::protobuf::RepeatedField* +V1LayerParameter::mutable_blob_share_mode() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blob_share_mode) + return &blob_share_mode_; +} + +// repeated float blobs_lr = 7; +int V1LayerParameter::blobs_lr_size() const { + return blobs_lr_.size(); +} +void V1LayerParameter::clear_blobs_lr() { + blobs_lr_.Clear(); +} +float V1LayerParameter::blobs_lr(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blobs_lr) + return blobs_lr_.Get(index); +} +void V1LayerParameter::set_blobs_lr(int index, float value) { + blobs_lr_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.blobs_lr) +} +void V1LayerParameter::add_blobs_lr(float value) { + blobs_lr_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blobs_lr) +} +const ::google::protobuf::RepeatedField< float >& +V1LayerParameter::blobs_lr() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blobs_lr) + return blobs_lr_; +} +::google::protobuf::RepeatedField< float >* +V1LayerParameter::mutable_blobs_lr() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blobs_lr) + return &blobs_lr_; +} + +// repeated float weight_decay = 8; +int V1LayerParameter::weight_decay_size() const { + return weight_decay_.size(); +} +void V1LayerParameter::clear_weight_decay() { + weight_decay_.Clear(); +} +float V1LayerParameter::weight_decay(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.weight_decay) + return weight_decay_.Get(index); +} +void V1LayerParameter::set_weight_decay(int index, float value) { + weight_decay_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.weight_decay) +} +void V1LayerParameter::add_weight_decay(float value) { + weight_decay_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.weight_decay) +} +const ::google::protobuf::RepeatedField< float >& +V1LayerParameter::weight_decay() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.weight_decay) + return weight_decay_; +} +::google::protobuf::RepeatedField< float >* +V1LayerParameter::mutable_weight_decay() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.weight_decay) + return &weight_decay_; +} + +// repeated float loss_weight = 35; +int V1LayerParameter::loss_weight_size() const { + return loss_weight_.size(); +} +void V1LayerParameter::clear_loss_weight() { + loss_weight_.Clear(); +} +float V1LayerParameter::loss_weight(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.loss_weight) + return loss_weight_.Get(index); +} +void V1LayerParameter::set_loss_weight(int index, float value) { + loss_weight_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.loss_weight) +} +void V1LayerParameter::add_loss_weight(float value) { + loss_weight_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.loss_weight) +} +const ::google::protobuf::RepeatedField< float >& +V1LayerParameter::loss_weight() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.loss_weight) + return loss_weight_; +} +::google::protobuf::RepeatedField< float >* +V1LayerParameter::mutable_loss_weight() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.loss_weight) + return &loss_weight_; +} + +// optional .caffe.AccuracyParameter accuracy_param = 27; +bool V1LayerParameter::has_accuracy_param() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +void V1LayerParameter::set_has_accuracy_param() { + _has_bits_[0] |= 0x00001000u; +} +void V1LayerParameter::clear_has_accuracy_param() { + _has_bits_[0] &= ~0x00001000u; +} +void V1LayerParameter::clear_accuracy_param() { + if (accuracy_param_ != NULL) accuracy_param_->::caffe::AccuracyParameter::Clear(); + clear_has_accuracy_param(); +} +const ::caffe::AccuracyParameter& V1LayerParameter::accuracy_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.accuracy_param) + return accuracy_param_ != NULL ? *accuracy_param_ + : *::caffe::AccuracyParameter::internal_default_instance(); +} +::caffe::AccuracyParameter* V1LayerParameter::mutable_accuracy_param() { + set_has_accuracy_param(); + if (accuracy_param_ == NULL) { + accuracy_param_ = new ::caffe::AccuracyParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.accuracy_param) + return accuracy_param_; +} +::caffe::AccuracyParameter* V1LayerParameter::release_accuracy_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.accuracy_param) + clear_has_accuracy_param(); + ::caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param) { + delete accuracy_param_; + accuracy_param_ = accuracy_param; + if (accuracy_param) { + set_has_accuracy_param(); + } else { + clear_has_accuracy_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.accuracy_param) +} + +// optional .caffe.ArgMaxParameter argmax_param = 23; +bool V1LayerParameter::has_argmax_param() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +void V1LayerParameter::set_has_argmax_param() { + _has_bits_[0] |= 0x00002000u; +} +void V1LayerParameter::clear_has_argmax_param() { + _has_bits_[0] &= ~0x00002000u; +} +void V1LayerParameter::clear_argmax_param() { + if (argmax_param_ != NULL) argmax_param_->::caffe::ArgMaxParameter::Clear(); + clear_has_argmax_param(); +} +const ::caffe::ArgMaxParameter& V1LayerParameter::argmax_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.argmax_param) + return argmax_param_ != NULL ? *argmax_param_ + : *::caffe::ArgMaxParameter::internal_default_instance(); +} +::caffe::ArgMaxParameter* V1LayerParameter::mutable_argmax_param() { + set_has_argmax_param(); + if (argmax_param_ == NULL) { + argmax_param_ = new ::caffe::ArgMaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.argmax_param) + return argmax_param_; +} +::caffe::ArgMaxParameter* V1LayerParameter::release_argmax_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.argmax_param) + clear_has_argmax_param(); + ::caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param) { + delete argmax_param_; + argmax_param_ = argmax_param; + if (argmax_param) { + set_has_argmax_param(); + } else { + clear_has_argmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.argmax_param) +} + +// optional .caffe.ConcatParameter concat_param = 9; +bool V1LayerParameter::has_concat_param() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +void V1LayerParameter::set_has_concat_param() { + _has_bits_[0] |= 0x00004000u; +} +void V1LayerParameter::clear_has_concat_param() { + _has_bits_[0] &= ~0x00004000u; +} +void V1LayerParameter::clear_concat_param() { + if (concat_param_ != NULL) concat_param_->::caffe::ConcatParameter::Clear(); + clear_has_concat_param(); +} +const ::caffe::ConcatParameter& V1LayerParameter::concat_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.concat_param) + return concat_param_ != NULL ? *concat_param_ + : *::caffe::ConcatParameter::internal_default_instance(); +} +::caffe::ConcatParameter* V1LayerParameter::mutable_concat_param() { + set_has_concat_param(); + if (concat_param_ == NULL) { + concat_param_ = new ::caffe::ConcatParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.concat_param) + return concat_param_; +} +::caffe::ConcatParameter* V1LayerParameter::release_concat_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.concat_param) + clear_has_concat_param(); + ::caffe::ConcatParameter* temp = concat_param_; + concat_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_concat_param(::caffe::ConcatParameter* concat_param) { + delete concat_param_; + concat_param_ = concat_param; + if (concat_param) { + set_has_concat_param(); + } else { + clear_has_concat_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.concat_param) +} + +// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40; +bool V1LayerParameter::has_contrastive_loss_param() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +void V1LayerParameter::set_has_contrastive_loss_param() { + _has_bits_[0] |= 0x00008000u; +} +void V1LayerParameter::clear_has_contrastive_loss_param() { + _has_bits_[0] &= ~0x00008000u; +} +void V1LayerParameter::clear_contrastive_loss_param() { + if (contrastive_loss_param_ != NULL) contrastive_loss_param_->::caffe::ContrastiveLossParameter::Clear(); + clear_has_contrastive_loss_param(); +} +const ::caffe::ContrastiveLossParameter& V1LayerParameter::contrastive_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.contrastive_loss_param) + return contrastive_loss_param_ != NULL ? *contrastive_loss_param_ + : *::caffe::ContrastiveLossParameter::internal_default_instance(); +} +::caffe::ContrastiveLossParameter* V1LayerParameter::mutable_contrastive_loss_param() { + set_has_contrastive_loss_param(); + if (contrastive_loss_param_ == NULL) { + contrastive_loss_param_ = new ::caffe::ContrastiveLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.contrastive_loss_param) + return contrastive_loss_param_; +} +::caffe::ContrastiveLossParameter* V1LayerParameter::release_contrastive_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.contrastive_loss_param) + clear_has_contrastive_loss_param(); + ::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param) { + delete contrastive_loss_param_; + contrastive_loss_param_ = contrastive_loss_param; + if (contrastive_loss_param) { + set_has_contrastive_loss_param(); + } else { + clear_has_contrastive_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.contrastive_loss_param) +} + +// optional .caffe.ConvolutionParameter convolution_param = 10; +bool V1LayerParameter::has_convolution_param() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +void V1LayerParameter::set_has_convolution_param() { + _has_bits_[0] |= 0x00010000u; +} +void V1LayerParameter::clear_has_convolution_param() { + _has_bits_[0] &= ~0x00010000u; +} +void V1LayerParameter::clear_convolution_param() { + if (convolution_param_ != NULL) convolution_param_->::caffe::ConvolutionParameter::Clear(); + clear_has_convolution_param(); +} +const ::caffe::ConvolutionParameter& V1LayerParameter::convolution_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.convolution_param) + return convolution_param_ != NULL ? *convolution_param_ + : *::caffe::ConvolutionParameter::internal_default_instance(); +} +::caffe::ConvolutionParameter* V1LayerParameter::mutable_convolution_param() { + set_has_convolution_param(); + if (convolution_param_ == NULL) { + convolution_param_ = new ::caffe::ConvolutionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.convolution_param) + return convolution_param_; +} +::caffe::ConvolutionParameter* V1LayerParameter::release_convolution_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.convolution_param) + clear_has_convolution_param(); + ::caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param) { + delete convolution_param_; + convolution_param_ = convolution_param; + if (convolution_param) { + set_has_convolution_param(); + } else { + clear_has_convolution_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.convolution_param) +} + +// optional .caffe.DataParameter data_param = 11; +bool V1LayerParameter::has_data_param() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +void V1LayerParameter::set_has_data_param() { + _has_bits_[0] |= 0x00020000u; +} +void V1LayerParameter::clear_has_data_param() { + _has_bits_[0] &= ~0x00020000u; +} +void V1LayerParameter::clear_data_param() { + if (data_param_ != NULL) data_param_->::caffe::DataParameter::Clear(); + clear_has_data_param(); +} +const ::caffe::DataParameter& V1LayerParameter::data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.data_param) + return data_param_ != NULL ? *data_param_ + : *::caffe::DataParameter::internal_default_instance(); +} +::caffe::DataParameter* V1LayerParameter::mutable_data_param() { + set_has_data_param(); + if (data_param_ == NULL) { + data_param_ = new ::caffe::DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.data_param) + return data_param_; +} +::caffe::DataParameter* V1LayerParameter::release_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.data_param) + clear_has_data_param(); + ::caffe::DataParameter* temp = data_param_; + data_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_data_param(::caffe::DataParameter* data_param) { + delete data_param_; + data_param_ = data_param; + if (data_param) { + set_has_data_param(); + } else { + clear_has_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.data_param) +} + +// optional .caffe.DropoutParameter dropout_param = 12; +bool V1LayerParameter::has_dropout_param() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +void V1LayerParameter::set_has_dropout_param() { + _has_bits_[0] |= 0x00040000u; +} +void V1LayerParameter::clear_has_dropout_param() { + _has_bits_[0] &= ~0x00040000u; +} +void V1LayerParameter::clear_dropout_param() { + if (dropout_param_ != NULL) dropout_param_->::caffe::DropoutParameter::Clear(); + clear_has_dropout_param(); +} +const ::caffe::DropoutParameter& V1LayerParameter::dropout_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.dropout_param) + return dropout_param_ != NULL ? *dropout_param_ + : *::caffe::DropoutParameter::internal_default_instance(); +} +::caffe::DropoutParameter* V1LayerParameter::mutable_dropout_param() { + set_has_dropout_param(); + if (dropout_param_ == NULL) { + dropout_param_ = new ::caffe::DropoutParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.dropout_param) + return dropout_param_; +} +::caffe::DropoutParameter* V1LayerParameter::release_dropout_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.dropout_param) + clear_has_dropout_param(); + ::caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param) { + delete dropout_param_; + dropout_param_ = dropout_param; + if (dropout_param) { + set_has_dropout_param(); + } else { + clear_has_dropout_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.dropout_param) +} + +// optional .caffe.DummyDataParameter dummy_data_param = 26; +bool V1LayerParameter::has_dummy_data_param() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +void V1LayerParameter::set_has_dummy_data_param() { + _has_bits_[0] |= 0x00080000u; +} +void V1LayerParameter::clear_has_dummy_data_param() { + _has_bits_[0] &= ~0x00080000u; +} +void V1LayerParameter::clear_dummy_data_param() { + if (dummy_data_param_ != NULL) dummy_data_param_->::caffe::DummyDataParameter::Clear(); + clear_has_dummy_data_param(); +} +const ::caffe::DummyDataParameter& V1LayerParameter::dummy_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.dummy_data_param) + return dummy_data_param_ != NULL ? *dummy_data_param_ + : *::caffe::DummyDataParameter::internal_default_instance(); +} +::caffe::DummyDataParameter* V1LayerParameter::mutable_dummy_data_param() { + set_has_dummy_data_param(); + if (dummy_data_param_ == NULL) { + dummy_data_param_ = new ::caffe::DummyDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.dummy_data_param) + return dummy_data_param_; +} +::caffe::DummyDataParameter* V1LayerParameter::release_dummy_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.dummy_data_param) + clear_has_dummy_data_param(); + ::caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param) { + delete dummy_data_param_; + dummy_data_param_ = dummy_data_param; + if (dummy_data_param) { + set_has_dummy_data_param(); + } else { + clear_has_dummy_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.dummy_data_param) +} + +// optional .caffe.EltwiseParameter eltwise_param = 24; +bool V1LayerParameter::has_eltwise_param() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +void V1LayerParameter::set_has_eltwise_param() { + _has_bits_[0] |= 0x00100000u; +} +void V1LayerParameter::clear_has_eltwise_param() { + _has_bits_[0] &= ~0x00100000u; +} +void V1LayerParameter::clear_eltwise_param() { + if (eltwise_param_ != NULL) eltwise_param_->::caffe::EltwiseParameter::Clear(); + clear_has_eltwise_param(); +} +const ::caffe::EltwiseParameter& V1LayerParameter::eltwise_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.eltwise_param) + return eltwise_param_ != NULL ? *eltwise_param_ + : *::caffe::EltwiseParameter::internal_default_instance(); +} +::caffe::EltwiseParameter* V1LayerParameter::mutable_eltwise_param() { + set_has_eltwise_param(); + if (eltwise_param_ == NULL) { + eltwise_param_ = new ::caffe::EltwiseParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.eltwise_param) + return eltwise_param_; +} +::caffe::EltwiseParameter* V1LayerParameter::release_eltwise_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.eltwise_param) + clear_has_eltwise_param(); + ::caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param) { + delete eltwise_param_; + eltwise_param_ = eltwise_param; + if (eltwise_param) { + set_has_eltwise_param(); + } else { + clear_has_eltwise_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.eltwise_param) +} + +// optional .caffe.ExpParameter exp_param = 41; +bool V1LayerParameter::has_exp_param() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +void V1LayerParameter::set_has_exp_param() { + _has_bits_[0] |= 0x00200000u; +} +void V1LayerParameter::clear_has_exp_param() { + _has_bits_[0] &= ~0x00200000u; +} +void V1LayerParameter::clear_exp_param() { + if (exp_param_ != NULL) exp_param_->::caffe::ExpParameter::Clear(); + clear_has_exp_param(); +} +const ::caffe::ExpParameter& V1LayerParameter::exp_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.exp_param) + return exp_param_ != NULL ? *exp_param_ + : *::caffe::ExpParameter::internal_default_instance(); +} +::caffe::ExpParameter* V1LayerParameter::mutable_exp_param() { + set_has_exp_param(); + if (exp_param_ == NULL) { + exp_param_ = new ::caffe::ExpParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.exp_param) + return exp_param_; +} +::caffe::ExpParameter* V1LayerParameter::release_exp_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.exp_param) + clear_has_exp_param(); + ::caffe::ExpParameter* temp = exp_param_; + exp_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_exp_param(::caffe::ExpParameter* exp_param) { + delete exp_param_; + exp_param_ = exp_param; + if (exp_param) { + set_has_exp_param(); + } else { + clear_has_exp_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.exp_param) +} + +// optional .caffe.HDF5DataParameter hdf5_data_param = 13; +bool V1LayerParameter::has_hdf5_data_param() const { + return (_has_bits_[0] & 0x00400000u) != 0; +} +void V1LayerParameter::set_has_hdf5_data_param() { + _has_bits_[0] |= 0x00400000u; +} +void V1LayerParameter::clear_has_hdf5_data_param() { + _has_bits_[0] &= ~0x00400000u; +} +void V1LayerParameter::clear_hdf5_data_param() { + if (hdf5_data_param_ != NULL) hdf5_data_param_->::caffe::HDF5DataParameter::Clear(); + clear_has_hdf5_data_param(); +} +const ::caffe::HDF5DataParameter& V1LayerParameter::hdf5_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hdf5_data_param) + return hdf5_data_param_ != NULL ? *hdf5_data_param_ + : *::caffe::HDF5DataParameter::internal_default_instance(); +} +::caffe::HDF5DataParameter* V1LayerParameter::mutable_hdf5_data_param() { + set_has_hdf5_data_param(); + if (hdf5_data_param_ == NULL) { + hdf5_data_param_ = new ::caffe::HDF5DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hdf5_data_param) + return hdf5_data_param_; +} +::caffe::HDF5DataParameter* V1LayerParameter::release_hdf5_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hdf5_data_param) + clear_has_hdf5_data_param(); + ::caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param) { + delete hdf5_data_param_; + hdf5_data_param_ = hdf5_data_param; + if (hdf5_data_param) { + set_has_hdf5_data_param(); + } else { + clear_has_hdf5_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hdf5_data_param) +} + +// optional .caffe.HDF5OutputParameter hdf5_output_param = 14; +bool V1LayerParameter::has_hdf5_output_param() const { + return (_has_bits_[0] & 0x00800000u) != 0; +} +void V1LayerParameter::set_has_hdf5_output_param() { + _has_bits_[0] |= 0x00800000u; +} +void V1LayerParameter::clear_has_hdf5_output_param() { + _has_bits_[0] &= ~0x00800000u; +} +void V1LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + clear_has_hdf5_output_param(); +} +const ::caffe::HDF5OutputParameter& V1LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hdf5_output_param) + return hdf5_output_param_ != NULL ? *hdf5_output_param_ + : *::caffe::HDF5OutputParameter::internal_default_instance(); +} +::caffe::HDF5OutputParameter* V1LayerParameter::mutable_hdf5_output_param() { + set_has_hdf5_output_param(); + if (hdf5_output_param_ == NULL) { + hdf5_output_param_ = new ::caffe::HDF5OutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hdf5_output_param) + return hdf5_output_param_; +} +::caffe::HDF5OutputParameter* V1LayerParameter::release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hdf5_output_param) + clear_has_hdf5_output_param(); + ::caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) { + delete hdf5_output_param_; + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + set_has_hdf5_output_param(); + } else { + clear_has_hdf5_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hdf5_output_param) +} + +// optional .caffe.HingeLossParameter hinge_loss_param = 29; +bool V1LayerParameter::has_hinge_loss_param() const { + return (_has_bits_[0] & 0x01000000u) != 0; +} +void V1LayerParameter::set_has_hinge_loss_param() { + _has_bits_[0] |= 0x01000000u; +} +void V1LayerParameter::clear_has_hinge_loss_param() { + _has_bits_[0] &= ~0x01000000u; +} +void V1LayerParameter::clear_hinge_loss_param() { + if (hinge_loss_param_ != NULL) hinge_loss_param_->::caffe::HingeLossParameter::Clear(); + clear_has_hinge_loss_param(); +} +const ::caffe::HingeLossParameter& V1LayerParameter::hinge_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hinge_loss_param) + return hinge_loss_param_ != NULL ? *hinge_loss_param_ + : *::caffe::HingeLossParameter::internal_default_instance(); +} +::caffe::HingeLossParameter* V1LayerParameter::mutable_hinge_loss_param() { + set_has_hinge_loss_param(); + if (hinge_loss_param_ == NULL) { + hinge_loss_param_ = new ::caffe::HingeLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hinge_loss_param) + return hinge_loss_param_; +} +::caffe::HingeLossParameter* V1LayerParameter::release_hinge_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hinge_loss_param) + clear_has_hinge_loss_param(); + ::caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param) { + delete hinge_loss_param_; + hinge_loss_param_ = hinge_loss_param; + if (hinge_loss_param) { + set_has_hinge_loss_param(); + } else { + clear_has_hinge_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hinge_loss_param) +} + +// optional .caffe.ImageDataParameter image_data_param = 15; +bool V1LayerParameter::has_image_data_param() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +void V1LayerParameter::set_has_image_data_param() { + _has_bits_[0] |= 0x02000000u; +} +void V1LayerParameter::clear_has_image_data_param() { + _has_bits_[0] &= ~0x02000000u; +} +void V1LayerParameter::clear_image_data_param() { + if (image_data_param_ != NULL) image_data_param_->::caffe::ImageDataParameter::Clear(); + clear_has_image_data_param(); +} +const ::caffe::ImageDataParameter& V1LayerParameter::image_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.image_data_param) + return image_data_param_ != NULL ? *image_data_param_ + : *::caffe::ImageDataParameter::internal_default_instance(); +} +::caffe::ImageDataParameter* V1LayerParameter::mutable_image_data_param() { + set_has_image_data_param(); + if (image_data_param_ == NULL) { + image_data_param_ = new ::caffe::ImageDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.image_data_param) + return image_data_param_; +} +::caffe::ImageDataParameter* V1LayerParameter::release_image_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.image_data_param) + clear_has_image_data_param(); + ::caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param) { + delete image_data_param_; + image_data_param_ = image_data_param; + if (image_data_param) { + set_has_image_data_param(); + } else { + clear_has_image_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.image_data_param) +} + +// optional .caffe.InfogainLossParameter infogain_loss_param = 16; +bool V1LayerParameter::has_infogain_loss_param() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +void V1LayerParameter::set_has_infogain_loss_param() { + _has_bits_[0] |= 0x04000000u; +} +void V1LayerParameter::clear_has_infogain_loss_param() { + _has_bits_[0] &= ~0x04000000u; +} +void V1LayerParameter::clear_infogain_loss_param() { + if (infogain_loss_param_ != NULL) infogain_loss_param_->::caffe::InfogainLossParameter::Clear(); + clear_has_infogain_loss_param(); +} +const ::caffe::InfogainLossParameter& V1LayerParameter::infogain_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.infogain_loss_param) + return infogain_loss_param_ != NULL ? *infogain_loss_param_ + : *::caffe::InfogainLossParameter::internal_default_instance(); +} +::caffe::InfogainLossParameter* V1LayerParameter::mutable_infogain_loss_param() { + set_has_infogain_loss_param(); + if (infogain_loss_param_ == NULL) { + infogain_loss_param_ = new ::caffe::InfogainLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.infogain_loss_param) + return infogain_loss_param_; +} +::caffe::InfogainLossParameter* V1LayerParameter::release_infogain_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.infogain_loss_param) + clear_has_infogain_loss_param(); + ::caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param) { + delete infogain_loss_param_; + infogain_loss_param_ = infogain_loss_param; + if (infogain_loss_param) { + set_has_infogain_loss_param(); + } else { + clear_has_infogain_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.infogain_loss_param) +} + +// optional .caffe.InnerProductParameter inner_product_param = 17; +bool V1LayerParameter::has_inner_product_param() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +void V1LayerParameter::set_has_inner_product_param() { + _has_bits_[0] |= 0x08000000u; +} +void V1LayerParameter::clear_has_inner_product_param() { + _has_bits_[0] &= ~0x08000000u; +} +void V1LayerParameter::clear_inner_product_param() { + if (inner_product_param_ != NULL) inner_product_param_->::caffe::InnerProductParameter::Clear(); + clear_has_inner_product_param(); +} +const ::caffe::InnerProductParameter& V1LayerParameter::inner_product_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.inner_product_param) + return inner_product_param_ != NULL ? *inner_product_param_ + : *::caffe::InnerProductParameter::internal_default_instance(); +} +::caffe::InnerProductParameter* V1LayerParameter::mutable_inner_product_param() { + set_has_inner_product_param(); + if (inner_product_param_ == NULL) { + inner_product_param_ = new ::caffe::InnerProductParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.inner_product_param) + return inner_product_param_; +} +::caffe::InnerProductParameter* V1LayerParameter::release_inner_product_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.inner_product_param) + clear_has_inner_product_param(); + ::caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param) { + delete inner_product_param_; + inner_product_param_ = inner_product_param; + if (inner_product_param) { + set_has_inner_product_param(); + } else { + clear_has_inner_product_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.inner_product_param) +} + +// optional .caffe.LRNParameter lrn_param = 18; +bool V1LayerParameter::has_lrn_param() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +void V1LayerParameter::set_has_lrn_param() { + _has_bits_[0] |= 0x10000000u; +} +void V1LayerParameter::clear_has_lrn_param() { + _has_bits_[0] &= ~0x10000000u; +} +void V1LayerParameter::clear_lrn_param() { + if (lrn_param_ != NULL) lrn_param_->::caffe::LRNParameter::Clear(); + clear_has_lrn_param(); +} +const ::caffe::LRNParameter& V1LayerParameter::lrn_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.lrn_param) + return lrn_param_ != NULL ? *lrn_param_ + : *::caffe::LRNParameter::internal_default_instance(); +} +::caffe::LRNParameter* V1LayerParameter::mutable_lrn_param() { + set_has_lrn_param(); + if (lrn_param_ == NULL) { + lrn_param_ = new ::caffe::LRNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.lrn_param) + return lrn_param_; +} +::caffe::LRNParameter* V1LayerParameter::release_lrn_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.lrn_param) + clear_has_lrn_param(); + ::caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_lrn_param(::caffe::LRNParameter* lrn_param) { + delete lrn_param_; + lrn_param_ = lrn_param; + if (lrn_param) { + set_has_lrn_param(); + } else { + clear_has_lrn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.lrn_param) +} + +// optional .caffe.MemoryDataParameter memory_data_param = 22; +bool V1LayerParameter::has_memory_data_param() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +void V1LayerParameter::set_has_memory_data_param() { + _has_bits_[0] |= 0x20000000u; +} +void V1LayerParameter::clear_has_memory_data_param() { + _has_bits_[0] &= ~0x20000000u; +} +void V1LayerParameter::clear_memory_data_param() { + if (memory_data_param_ != NULL) memory_data_param_->::caffe::MemoryDataParameter::Clear(); + clear_has_memory_data_param(); +} +const ::caffe::MemoryDataParameter& V1LayerParameter::memory_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.memory_data_param) + return memory_data_param_ != NULL ? *memory_data_param_ + : *::caffe::MemoryDataParameter::internal_default_instance(); +} +::caffe::MemoryDataParameter* V1LayerParameter::mutable_memory_data_param() { + set_has_memory_data_param(); + if (memory_data_param_ == NULL) { + memory_data_param_ = new ::caffe::MemoryDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.memory_data_param) + return memory_data_param_; +} +::caffe::MemoryDataParameter* V1LayerParameter::release_memory_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.memory_data_param) + clear_has_memory_data_param(); + ::caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param) { + delete memory_data_param_; + memory_data_param_ = memory_data_param; + if (memory_data_param) { + set_has_memory_data_param(); + } else { + clear_has_memory_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.memory_data_param) +} + +// optional .caffe.MVNParameter mvn_param = 34; +bool V1LayerParameter::has_mvn_param() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +void V1LayerParameter::set_has_mvn_param() { + _has_bits_[0] |= 0x40000000u; +} +void V1LayerParameter::clear_has_mvn_param() { + _has_bits_[0] &= ~0x40000000u; +} +void V1LayerParameter::clear_mvn_param() { + if (mvn_param_ != NULL) mvn_param_->::caffe::MVNParameter::Clear(); + clear_has_mvn_param(); +} +const ::caffe::MVNParameter& V1LayerParameter::mvn_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.mvn_param) + return mvn_param_ != NULL ? *mvn_param_ + : *::caffe::MVNParameter::internal_default_instance(); +} +::caffe::MVNParameter* V1LayerParameter::mutable_mvn_param() { + set_has_mvn_param(); + if (mvn_param_ == NULL) { + mvn_param_ = new ::caffe::MVNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.mvn_param) + return mvn_param_; +} +::caffe::MVNParameter* V1LayerParameter::release_mvn_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.mvn_param) + clear_has_mvn_param(); + ::caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_mvn_param(::caffe::MVNParameter* mvn_param) { + delete mvn_param_; + mvn_param_ = mvn_param; + if (mvn_param) { + set_has_mvn_param(); + } else { + clear_has_mvn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.mvn_param) +} + +// optional .caffe.PoolingParameter pooling_param = 19; +bool V1LayerParameter::has_pooling_param() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +void V1LayerParameter::set_has_pooling_param() { + _has_bits_[0] |= 0x80000000u; +} +void V1LayerParameter::clear_has_pooling_param() { + _has_bits_[0] &= ~0x80000000u; +} +void V1LayerParameter::clear_pooling_param() { + if (pooling_param_ != NULL) pooling_param_->::caffe::PoolingParameter::Clear(); + clear_has_pooling_param(); +} +const ::caffe::PoolingParameter& V1LayerParameter::pooling_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.pooling_param) + return pooling_param_ != NULL ? *pooling_param_ + : *::caffe::PoolingParameter::internal_default_instance(); +} +::caffe::PoolingParameter* V1LayerParameter::mutable_pooling_param() { + set_has_pooling_param(); + if (pooling_param_ == NULL) { + pooling_param_ = new ::caffe::PoolingParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.pooling_param) + return pooling_param_; +} +::caffe::PoolingParameter* V1LayerParameter::release_pooling_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.pooling_param) + clear_has_pooling_param(); + ::caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param) { + delete pooling_param_; + pooling_param_ = pooling_param; + if (pooling_param) { + set_has_pooling_param(); + } else { + clear_has_pooling_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.pooling_param) +} + +// optional .caffe.PowerParameter power_param = 21; +bool V1LayerParameter::has_power_param() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +void V1LayerParameter::set_has_power_param() { + _has_bits_[1] |= 0x00000001u; +} +void V1LayerParameter::clear_has_power_param() { + _has_bits_[1] &= ~0x00000001u; +} +void V1LayerParameter::clear_power_param() { + if (power_param_ != NULL) power_param_->::caffe::PowerParameter::Clear(); + clear_has_power_param(); +} +const ::caffe::PowerParameter& V1LayerParameter::power_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.power_param) + return power_param_ != NULL ? *power_param_ + : *::caffe::PowerParameter::internal_default_instance(); +} +::caffe::PowerParameter* V1LayerParameter::mutable_power_param() { + set_has_power_param(); + if (power_param_ == NULL) { + power_param_ = new ::caffe::PowerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.power_param) + return power_param_; +} +::caffe::PowerParameter* V1LayerParameter::release_power_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.power_param) + clear_has_power_param(); + ::caffe::PowerParameter* temp = power_param_; + power_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_power_param(::caffe::PowerParameter* power_param) { + delete power_param_; + power_param_ = power_param; + if (power_param) { + set_has_power_param(); + } else { + clear_has_power_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.power_param) +} + +// optional .caffe.ReLUParameter relu_param = 30; +bool V1LayerParameter::has_relu_param() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +void V1LayerParameter::set_has_relu_param() { + _has_bits_[1] |= 0x00000002u; +} +void V1LayerParameter::clear_has_relu_param() { + _has_bits_[1] &= ~0x00000002u; +} +void V1LayerParameter::clear_relu_param() { + if (relu_param_ != NULL) relu_param_->::caffe::ReLUParameter::Clear(); + clear_has_relu_param(); +} +const ::caffe::ReLUParameter& V1LayerParameter::relu_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.relu_param) + return relu_param_ != NULL ? *relu_param_ + : *::caffe::ReLUParameter::internal_default_instance(); +} +::caffe::ReLUParameter* V1LayerParameter::mutable_relu_param() { + set_has_relu_param(); + if (relu_param_ == NULL) { + relu_param_ = new ::caffe::ReLUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.relu_param) + return relu_param_; +} +::caffe::ReLUParameter* V1LayerParameter::release_relu_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.relu_param) + clear_has_relu_param(); + ::caffe::ReLUParameter* temp = relu_param_; + relu_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_relu_param(::caffe::ReLUParameter* relu_param) { + delete relu_param_; + relu_param_ = relu_param; + if (relu_param) { + set_has_relu_param(); + } else { + clear_has_relu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.relu_param) +} + +// optional .caffe.SigmoidParameter sigmoid_param = 38; +bool V1LayerParameter::has_sigmoid_param() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +void V1LayerParameter::set_has_sigmoid_param() { + _has_bits_[1] |= 0x00000004u; +} +void V1LayerParameter::clear_has_sigmoid_param() { + _has_bits_[1] &= ~0x00000004u; +} +void V1LayerParameter::clear_sigmoid_param() { + if (sigmoid_param_ != NULL) sigmoid_param_->::caffe::SigmoidParameter::Clear(); + clear_has_sigmoid_param(); +} +const ::caffe::SigmoidParameter& V1LayerParameter::sigmoid_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.sigmoid_param) + return sigmoid_param_ != NULL ? *sigmoid_param_ + : *::caffe::SigmoidParameter::internal_default_instance(); +} +::caffe::SigmoidParameter* V1LayerParameter::mutable_sigmoid_param() { + set_has_sigmoid_param(); + if (sigmoid_param_ == NULL) { + sigmoid_param_ = new ::caffe::SigmoidParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.sigmoid_param) + return sigmoid_param_; +} +::caffe::SigmoidParameter* V1LayerParameter::release_sigmoid_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.sigmoid_param) + clear_has_sigmoid_param(); + ::caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param) { + delete sigmoid_param_; + sigmoid_param_ = sigmoid_param; + if (sigmoid_param) { + set_has_sigmoid_param(); + } else { + clear_has_sigmoid_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.sigmoid_param) +} + +// optional .caffe.SoftmaxParameter softmax_param = 39; +bool V1LayerParameter::has_softmax_param() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +void V1LayerParameter::set_has_softmax_param() { + _has_bits_[1] |= 0x00000008u; +} +void V1LayerParameter::clear_has_softmax_param() { + _has_bits_[1] &= ~0x00000008u; +} +void V1LayerParameter::clear_softmax_param() { + if (softmax_param_ != NULL) softmax_param_->::caffe::SoftmaxParameter::Clear(); + clear_has_softmax_param(); +} +const ::caffe::SoftmaxParameter& V1LayerParameter::softmax_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.softmax_param) + return softmax_param_ != NULL ? *softmax_param_ + : *::caffe::SoftmaxParameter::internal_default_instance(); +} +::caffe::SoftmaxParameter* V1LayerParameter::mutable_softmax_param() { + set_has_softmax_param(); + if (softmax_param_ == NULL) { + softmax_param_ = new ::caffe::SoftmaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.softmax_param) + return softmax_param_; +} +::caffe::SoftmaxParameter* V1LayerParameter::release_softmax_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.softmax_param) + clear_has_softmax_param(); + ::caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param) { + delete softmax_param_; + softmax_param_ = softmax_param; + if (softmax_param) { + set_has_softmax_param(); + } else { + clear_has_softmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.softmax_param) +} + +// optional .caffe.SliceParameter slice_param = 31; +bool V1LayerParameter::has_slice_param() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +void V1LayerParameter::set_has_slice_param() { + _has_bits_[1] |= 0x00000010u; +} +void V1LayerParameter::clear_has_slice_param() { + _has_bits_[1] &= ~0x00000010u; +} +void V1LayerParameter::clear_slice_param() { + if (slice_param_ != NULL) slice_param_->::caffe::SliceParameter::Clear(); + clear_has_slice_param(); +} +const ::caffe::SliceParameter& V1LayerParameter::slice_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.slice_param) + return slice_param_ != NULL ? *slice_param_ + : *::caffe::SliceParameter::internal_default_instance(); +} +::caffe::SliceParameter* V1LayerParameter::mutable_slice_param() { + set_has_slice_param(); + if (slice_param_ == NULL) { + slice_param_ = new ::caffe::SliceParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.slice_param) + return slice_param_; +} +::caffe::SliceParameter* V1LayerParameter::release_slice_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.slice_param) + clear_has_slice_param(); + ::caffe::SliceParameter* temp = slice_param_; + slice_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_slice_param(::caffe::SliceParameter* slice_param) { + delete slice_param_; + slice_param_ = slice_param; + if (slice_param) { + set_has_slice_param(); + } else { + clear_has_slice_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.slice_param) +} + +// optional .caffe.TanHParameter tanh_param = 37; +bool V1LayerParameter::has_tanh_param() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +void V1LayerParameter::set_has_tanh_param() { + _has_bits_[1] |= 0x00000020u; +} +void V1LayerParameter::clear_has_tanh_param() { + _has_bits_[1] &= ~0x00000020u; +} +void V1LayerParameter::clear_tanh_param() { + if (tanh_param_ != NULL) tanh_param_->::caffe::TanHParameter::Clear(); + clear_has_tanh_param(); +} +const ::caffe::TanHParameter& V1LayerParameter::tanh_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.tanh_param) + return tanh_param_ != NULL ? *tanh_param_ + : *::caffe::TanHParameter::internal_default_instance(); +} +::caffe::TanHParameter* V1LayerParameter::mutable_tanh_param() { + set_has_tanh_param(); + if (tanh_param_ == NULL) { + tanh_param_ = new ::caffe::TanHParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.tanh_param) + return tanh_param_; +} +::caffe::TanHParameter* V1LayerParameter::release_tanh_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.tanh_param) + clear_has_tanh_param(); + ::caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_tanh_param(::caffe::TanHParameter* tanh_param) { + delete tanh_param_; + tanh_param_ = tanh_param; + if (tanh_param) { + set_has_tanh_param(); + } else { + clear_has_tanh_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.tanh_param) +} + +// optional .caffe.ThresholdParameter threshold_param = 25; +bool V1LayerParameter::has_threshold_param() const { + return (_has_bits_[1] & 0x00000040u) != 0; +} +void V1LayerParameter::set_has_threshold_param() { + _has_bits_[1] |= 0x00000040u; +} +void V1LayerParameter::clear_has_threshold_param() { + _has_bits_[1] &= ~0x00000040u; +} +void V1LayerParameter::clear_threshold_param() { + if (threshold_param_ != NULL) threshold_param_->::caffe::ThresholdParameter::Clear(); + clear_has_threshold_param(); +} +const ::caffe::ThresholdParameter& V1LayerParameter::threshold_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.threshold_param) + return threshold_param_ != NULL ? *threshold_param_ + : *::caffe::ThresholdParameter::internal_default_instance(); +} +::caffe::ThresholdParameter* V1LayerParameter::mutable_threshold_param() { + set_has_threshold_param(); + if (threshold_param_ == NULL) { + threshold_param_ = new ::caffe::ThresholdParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.threshold_param) + return threshold_param_; +} +::caffe::ThresholdParameter* V1LayerParameter::release_threshold_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.threshold_param) + clear_has_threshold_param(); + ::caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param) { + delete threshold_param_; + threshold_param_ = threshold_param; + if (threshold_param) { + set_has_threshold_param(); + } else { + clear_has_threshold_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.threshold_param) +} + +// optional .caffe.WindowDataParameter window_data_param = 20; +bool V1LayerParameter::has_window_data_param() const { + return (_has_bits_[1] & 0x00000080u) != 0; +} +void V1LayerParameter::set_has_window_data_param() { + _has_bits_[1] |= 0x00000080u; +} +void V1LayerParameter::clear_has_window_data_param() { + _has_bits_[1] &= ~0x00000080u; +} +void V1LayerParameter::clear_window_data_param() { + if (window_data_param_ != NULL) window_data_param_->::caffe::WindowDataParameter::Clear(); + clear_has_window_data_param(); +} +const ::caffe::WindowDataParameter& V1LayerParameter::window_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.window_data_param) + return window_data_param_ != NULL ? *window_data_param_ + : *::caffe::WindowDataParameter::internal_default_instance(); +} +::caffe::WindowDataParameter* V1LayerParameter::mutable_window_data_param() { + set_has_window_data_param(); + if (window_data_param_ == NULL) { + window_data_param_ = new ::caffe::WindowDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.window_data_param) + return window_data_param_; +} +::caffe::WindowDataParameter* V1LayerParameter::release_window_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.window_data_param) + clear_has_window_data_param(); + ::caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param) { + delete window_data_param_; + window_data_param_ = window_data_param; + if (window_data_param) { + set_has_window_data_param(); + } else { + clear_has_window_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.window_data_param) +} + +// optional .caffe.TransformationParameter transform_param = 36; +bool V1LayerParameter::has_transform_param() const { + return (_has_bits_[1] & 0x00000100u) != 0; +} +void V1LayerParameter::set_has_transform_param() { + _has_bits_[1] |= 0x00000100u; +} +void V1LayerParameter::clear_has_transform_param() { + _has_bits_[1] &= ~0x00000100u; +} +void V1LayerParameter::clear_transform_param() { + if (transform_param_ != NULL) transform_param_->::caffe::TransformationParameter::Clear(); + clear_has_transform_param(); +} +const ::caffe::TransformationParameter& V1LayerParameter::transform_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.transform_param) + return transform_param_ != NULL ? *transform_param_ + : *::caffe::TransformationParameter::internal_default_instance(); +} +::caffe::TransformationParameter* V1LayerParameter::mutable_transform_param() { + set_has_transform_param(); + if (transform_param_ == NULL) { + transform_param_ = new ::caffe::TransformationParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.transform_param) + return transform_param_; +} +::caffe::TransformationParameter* V1LayerParameter::release_transform_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.transform_param) + clear_has_transform_param(); + ::caffe::TransformationParameter* temp = transform_param_; + transform_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_transform_param(::caffe::TransformationParameter* transform_param) { + delete transform_param_; + transform_param_ = transform_param; + if (transform_param) { + set_has_transform_param(); + } else { + clear_has_transform_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.transform_param) +} + +// optional .caffe.LossParameter loss_param = 42; +bool V1LayerParameter::has_loss_param() const { + return (_has_bits_[1] & 0x00000200u) != 0; +} +void V1LayerParameter::set_has_loss_param() { + _has_bits_[1] |= 0x00000200u; +} +void V1LayerParameter::clear_has_loss_param() { + _has_bits_[1] &= ~0x00000200u; +} +void V1LayerParameter::clear_loss_param() { + if (loss_param_ != NULL) loss_param_->::caffe::LossParameter::Clear(); + clear_has_loss_param(); +} +const ::caffe::LossParameter& V1LayerParameter::loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.loss_param) + return loss_param_ != NULL ? *loss_param_ + : *::caffe::LossParameter::internal_default_instance(); +} +::caffe::LossParameter* V1LayerParameter::mutable_loss_param() { + set_has_loss_param(); + if (loss_param_ == NULL) { + loss_param_ = new ::caffe::LossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.loss_param) + return loss_param_; +} +::caffe::LossParameter* V1LayerParameter::release_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.loss_param) + clear_has_loss_param(); + ::caffe::LossParameter* temp = loss_param_; + loss_param_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_loss_param(::caffe::LossParameter* loss_param) { + delete loss_param_; + loss_param_ = loss_param; + if (loss_param) { + set_has_loss_param(); + } else { + clear_has_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.loss_param) +} + +// optional .caffe.V0LayerParameter layer = 1; +bool V1LayerParameter::has_layer() const { + return (_has_bits_[1] & 0x00000400u) != 0; +} +void V1LayerParameter::set_has_layer() { + _has_bits_[1] |= 0x00000400u; +} +void V1LayerParameter::clear_has_layer() { + _has_bits_[1] &= ~0x00000400u; +} +void V1LayerParameter::clear_layer() { + if (layer_ != NULL) layer_->::caffe::V0LayerParameter::Clear(); + clear_has_layer(); +} +const ::caffe::V0LayerParameter& V1LayerParameter::layer() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.layer) + return layer_ != NULL ? *layer_ + : *::caffe::V0LayerParameter::internal_default_instance(); +} +::caffe::V0LayerParameter* V1LayerParameter::mutable_layer() { + set_has_layer(); + if (layer_ == NULL) { + layer_ = new ::caffe::V0LayerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.layer) + return layer_; +} +::caffe::V0LayerParameter* V1LayerParameter::release_layer() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.layer) + clear_has_layer(); + ::caffe::V0LayerParameter* temp = layer_; + layer_ = NULL; + return temp; +} +void V1LayerParameter::set_allocated_layer(::caffe::V0LayerParameter* layer) { + delete layer_; + layer_ = layer; + if (layer) { + set_has_layer(); + } else { + clear_has_layer(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.layer) +} + +inline const V1LayerParameter* V1LayerParameter::internal_default_instance() { + return &V1LayerParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor() { + protobuf_AssignDescriptorsOnce(); + return V0LayerParameter_PoolMethod_descriptor_; +} +bool V0LayerParameter_PoolMethod_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const V0LayerParameter_PoolMethod V0LayerParameter::MAX; +const V0LayerParameter_PoolMethod V0LayerParameter::AVE; +const V0LayerParameter_PoolMethod V0LayerParameter::STOCHASTIC; +const V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MIN; +const V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MAX; +const int V0LayerParameter::PoolMethod_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +::std::string* V0LayerParameter::_default_det_crop_mode_ = NULL; +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int V0LayerParameter::kNameFieldNumber; +const int V0LayerParameter::kTypeFieldNumber; +const int V0LayerParameter::kNumOutputFieldNumber; +const int V0LayerParameter::kBiastermFieldNumber; +const int V0LayerParameter::kWeightFillerFieldNumber; +const int V0LayerParameter::kBiasFillerFieldNumber; +const int V0LayerParameter::kPadFieldNumber; +const int V0LayerParameter::kKernelsizeFieldNumber; +const int V0LayerParameter::kGroupFieldNumber; +const int V0LayerParameter::kStrideFieldNumber; +const int V0LayerParameter::kPoolFieldNumber; +const int V0LayerParameter::kDropoutRatioFieldNumber; +const int V0LayerParameter::kLocalSizeFieldNumber; +const int V0LayerParameter::kAlphaFieldNumber; +const int V0LayerParameter::kBetaFieldNumber; +const int V0LayerParameter::kKFieldNumber; +const int V0LayerParameter::kSourceFieldNumber; +const int V0LayerParameter::kScaleFieldNumber; +const int V0LayerParameter::kMeanfileFieldNumber; +const int V0LayerParameter::kBatchsizeFieldNumber; +const int V0LayerParameter::kCropsizeFieldNumber; +const int V0LayerParameter::kMirrorFieldNumber; +const int V0LayerParameter::kBlobsFieldNumber; +const int V0LayerParameter::kBlobsLrFieldNumber; +const int V0LayerParameter::kWeightDecayFieldNumber; +const int V0LayerParameter::kRandSkipFieldNumber; +const int V0LayerParameter::kDetFgThresholdFieldNumber; +const int V0LayerParameter::kDetBgThresholdFieldNumber; +const int V0LayerParameter::kDetFgFractionFieldNumber; +const int V0LayerParameter::kDetContextPadFieldNumber; +const int V0LayerParameter::kDetCropModeFieldNumber; +const int V0LayerParameter::kNewNumFieldNumber; +const int V0LayerParameter::kNewChannelsFieldNumber; +const int V0LayerParameter::kNewHeightFieldNumber; +const int V0LayerParameter::kNewWidthFieldNumber; +const int V0LayerParameter::kShuffleImagesFieldNumber; +const int V0LayerParameter::kConcatDimFieldNumber; +const int V0LayerParameter::kHdf5OutputParamFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +V0LayerParameter::V0LayerParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.V0LayerParameter) +} + +void V0LayerParameter::InitAsDefaultInstance() { + weight_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); + bias_filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); + hdf5_output_param_ = const_cast< ::caffe::HDF5OutputParameter*>( + ::caffe::HDF5OutputParameter::internal_default_instance()); +} + +V0LayerParameter::V0LayerParameter(const V0LayerParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.V0LayerParameter) +} + +void V0LayerParameter::SharedCtor() { + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + meanfile_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + det_crop_mode_.UnsafeSetDefault(_default_det_crop_mode_); + weight_filler_ = NULL; + bias_filler_ = NULL; + hdf5_output_param_ = NULL; + ::memset(&num_output_, 0, reinterpret_cast(&new_width_) - + reinterpret_cast(&num_output_) + sizeof(new_width_)); + concat_dim_ = 1u; + biasterm_ = true; + group_ = 1u; + stride_ = 1u; + dropout_ratio_ = 0.5f; + local_size_ = 5u; + alpha_ = 1; + beta_ = 0.75f; + k_ = 1; + scale_ = 1; + det_fg_threshold_ = 0.5f; + det_bg_threshold_ = 0.5f; + det_fg_fraction_ = 0.25f; + _cached_size_ = 0; +} + +V0LayerParameter::~V0LayerParameter() { + // @@protoc_insertion_point(destructor:caffe.V0LayerParameter) + SharedDtor(); +} + +void V0LayerParameter::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + meanfile_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + det_crop_mode_.DestroyNoArena(_default_det_crop_mode_); + if (this != &V0LayerParameter_default_instance_.get()) { + delete weight_filler_; + delete bias_filler_; + delete hdf5_output_param_; + } +} + +void V0LayerParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* V0LayerParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return V0LayerParameter_descriptor_; +} + +const V0LayerParameter& V0LayerParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed V0LayerParameter_default_instance_; + +V0LayerParameter* V0LayerParameter::New(::google::protobuf::Arena* arena) const { + V0LayerParameter* n = new V0LayerParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void V0LayerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.V0LayerParameter) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(V0LayerParameter, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + if (_has_bits_[0 / 32] & 255u) { + ZR_(num_output_, kernelsize_); + if (has_name()) { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + if (has_type()) { + type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + biasterm_ = true; + if (has_weight_filler()) { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + } + if (has_bias_filler()) { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + } + } + if (_has_bits_[8 / 32] & 65280u) { + group_ = 1u; + stride_ = 1u; + pool_ = 0; + dropout_ratio_ = 0.5f; + local_size_ = 5u; + alpha_ = 1; + beta_ = 0.75f; + k_ = 1; + } + if (_has_bits_[16 / 32] & 4128768u) { + ZR_(batchsize_, cropsize_); + if (has_source()) { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + scale_ = 1; + if (has_meanfile()) { + meanfile_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + mirror_ = false; + } + if (_has_bits_[24 / 32] & 4261412864u) { + ZR_(det_context_pad_, new_num_); + rand_skip_ = 0u; + det_fg_threshold_ = 0.5f; + det_bg_threshold_ = 0.5f; + det_fg_fraction_ = 0.25f; + if (has_det_crop_mode()) { + det_crop_mode_.ClearToDefaultNoArena(_default_det_crop_mode_); + } + } + if (_has_bits_[32 / 32] & 63u) { + ZR_(new_channels_, new_width_); + shuffle_images_ = false; + concat_dim_ = 1u; + if (has_hdf5_output_param()) { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + } + } + +#undef ZR_HELPER_ +#undef ZR_ + + blobs_.Clear(); + blobs_lr_.Clear(); + weight_decay_.Clear(); + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool V0LayerParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.V0LayerParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V0LayerParameter.name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_type; + break; + } + + // optional string type = 2; + case 2: { + if (tag == 18) { + parse_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V0LayerParameter.type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_num_output; + break; + } + + // optional uint32 num_output = 3; + case 3: { + if (tag == 24) { + parse_num_output: + set_has_num_output(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &num_output_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_biasterm; + break; + } + + // optional bool biasterm = 4 [default = true]; + case 4: { + if (tag == 32) { + parse_biasterm: + set_has_biasterm(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &biasterm_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_weight_filler; + break; + } + + // optional .caffe.FillerParameter weight_filler = 5; + case 5: { + if (tag == 42) { + parse_weight_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_weight_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_bias_filler; + break; + } + + // optional .caffe.FillerParameter bias_filler = 6; + case 6: { + if (tag == 50) { + parse_bias_filler: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bias_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_pad; + break; + } + + // optional uint32 pad = 7 [default = 0]; + case 7: { + if (tag == 56) { + parse_pad: + set_has_pad(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &pad_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_kernelsize; + break; + } + + // optional uint32 kernelsize = 8; + case 8: { + if (tag == 64) { + parse_kernelsize: + set_has_kernelsize(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &kernelsize_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_group; + break; + } + + // optional uint32 group = 9 [default = 1]; + case 9: { + if (tag == 72) { + parse_group: + set_has_group(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &group_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_stride; + break; + } + + // optional uint32 stride = 10 [default = 1]; + case 10: { + if (tag == 80) { + parse_stride: + set_has_stride(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stride_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_pool; + break; + } + + // optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + case 11: { + if (tag == 88) { + parse_pool: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::caffe::V0LayerParameter_PoolMethod_IsValid(value)) { + set_pool(static_cast< ::caffe::V0LayerParameter_PoolMethod >(value)); + } else { + mutable_unknown_fields()->AddVarint(11, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(101)) goto parse_dropout_ratio; + break; + } + + // optional float dropout_ratio = 12 [default = 0.5]; + case 12: { + if (tag == 101) { + parse_dropout_ratio: + set_has_dropout_ratio(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &dropout_ratio_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(104)) goto parse_local_size; + break; + } + + // optional uint32 local_size = 13 [default = 5]; + case 13: { + if (tag == 104) { + parse_local_size: + set_has_local_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &local_size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(117)) goto parse_alpha; + break; + } + + // optional float alpha = 14 [default = 1]; + case 14: { + if (tag == 117) { + parse_alpha: + set_has_alpha(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &alpha_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(125)) goto parse_beta; + break; + } + + // optional float beta = 15 [default = 0.75]; + case 15: { + if (tag == 125) { + parse_beta: + set_has_beta(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &beta_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(130)) goto parse_source; + break; + } + + // optional string source = 16; + case 16: { + if (tag == 130) { + parse_source: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_source())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V0LayerParameter.source"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(141)) goto parse_scale; + break; + } + + // optional float scale = 17 [default = 1]; + case 17: { + if (tag == 141) { + parse_scale: + set_has_scale(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &scale_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(146)) goto parse_meanfile; + break; + } + + // optional string meanfile = 18; + case 18: { + if (tag == 146) { + parse_meanfile: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_meanfile())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->meanfile().data(), this->meanfile().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V0LayerParameter.meanfile"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(152)) goto parse_batchsize; + break; + } + + // optional uint32 batchsize = 19; + case 19: { + if (tag == 152) { + parse_batchsize: + set_has_batchsize(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &batchsize_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(160)) goto parse_cropsize; + break; + } + + // optional uint32 cropsize = 20 [default = 0]; + case 20: { + if (tag == 160) { + parse_cropsize: + set_has_cropsize(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &cropsize_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(168)) goto parse_mirror; + break; + } + + // optional bool mirror = 21 [default = false]; + case 21: { + if (tag == 168) { + parse_mirror: + set_has_mirror(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &mirror_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(181)) goto parse_k; + break; + } + + // optional float k = 22 [default = 1]; + case 22: { + if (tag == 181) { + parse_k: + set_has_k(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &k_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(402)) goto parse_blobs; + break; + } + + // repeated .caffe.BlobProto blobs = 50; + case 50: { + if (tag == 402) { + parse_blobs: + DO_(input->IncrementRecursionDepth()); + parse_loop_blobs: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_blobs())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(402)) goto parse_loop_blobs; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(413)) goto parse_blobs_lr; + break; + } + + // repeated float blobs_lr = 51; + case 51: { + if (tag == 413) { + parse_blobs_lr: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 2, 413, input, this->mutable_blobs_lr()))); + } else if (tag == 410) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_blobs_lr()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(413)) goto parse_blobs_lr; + if (input->ExpectTag(421)) goto parse_weight_decay; + break; + } + + // repeated float weight_decay = 52; + case 52: { + if (tag == 421) { + parse_weight_decay: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 2, 421, input, this->mutable_weight_decay()))); + } else if (tag == 418) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_weight_decay()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(421)) goto parse_weight_decay; + if (input->ExpectTag(424)) goto parse_rand_skip; + break; + } + + // optional uint32 rand_skip = 53 [default = 0]; + case 53: { + if (tag == 424) { + parse_rand_skip: + set_has_rand_skip(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &rand_skip_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(437)) goto parse_det_fg_threshold; + break; + } + + // optional float det_fg_threshold = 54 [default = 0.5]; + case 54: { + if (tag == 437) { + parse_det_fg_threshold: + set_has_det_fg_threshold(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &det_fg_threshold_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(445)) goto parse_det_bg_threshold; + break; + } + + // optional float det_bg_threshold = 55 [default = 0.5]; + case 55: { + if (tag == 445) { + parse_det_bg_threshold: + set_has_det_bg_threshold(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &det_bg_threshold_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(453)) goto parse_det_fg_fraction; + break; + } + + // optional float det_fg_fraction = 56 [default = 0.25]; + case 56: { + if (tag == 453) { + parse_det_fg_fraction: + set_has_det_fg_fraction(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &det_fg_fraction_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(464)) goto parse_det_context_pad; + break; + } + + // optional uint32 det_context_pad = 58 [default = 0]; + case 58: { + if (tag == 464) { + parse_det_context_pad: + set_has_det_context_pad(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &det_context_pad_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(474)) goto parse_det_crop_mode; + break; + } + + // optional string det_crop_mode = 59 [default = "warp"]; + case 59: { + if (tag == 474) { + parse_det_crop_mode: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_det_crop_mode())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->det_crop_mode().data(), this->det_crop_mode().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "caffe.V0LayerParameter.det_crop_mode"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(480)) goto parse_new_num; + break; + } + + // optional int32 new_num = 60 [default = 0]; + case 60: { + if (tag == 480) { + parse_new_num: + set_has_new_num(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &new_num_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(488)) goto parse_new_channels; + break; + } + + // optional int32 new_channels = 61 [default = 0]; + case 61: { + if (tag == 488) { + parse_new_channels: + set_has_new_channels(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &new_channels_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(496)) goto parse_new_height; + break; + } + + // optional int32 new_height = 62 [default = 0]; + case 62: { + if (tag == 496) { + parse_new_height: + set_has_new_height(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &new_height_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(504)) goto parse_new_width; + break; + } + + // optional int32 new_width = 63 [default = 0]; + case 63: { + if (tag == 504) { + parse_new_width: + set_has_new_width(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &new_width_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(512)) goto parse_shuffle_images; + break; + } + + // optional bool shuffle_images = 64 [default = false]; + case 64: { + if (tag == 512) { + parse_shuffle_images: + set_has_shuffle_images(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &shuffle_images_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(520)) goto parse_concat_dim; + break; + } + + // optional uint32 concat_dim = 65 [default = 1]; + case 65: { + if (tag == 520) { + parse_concat_dim: + set_has_concat_dim(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &concat_dim_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(8010)) goto parse_hdf5_output_param; + break; + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 1001; + case 1001: { + if (tag == 8010) { + parse_hdf5_output_param: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_hdf5_output_param())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.V0LayerParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.V0LayerParameter) + return false; +#undef DO_ +} + +void V0LayerParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.V0LayerParameter) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional string type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->type(), output); + } + + // optional uint32 num_output = 3; + if (has_num_output()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->num_output(), output); + } + + // optional bool biasterm = 4 [default = true]; + if (has_biasterm()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->biasterm(), output); + } + + // optional .caffe.FillerParameter weight_filler = 5; + if (has_weight_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *this->weight_filler_, output); + } + + // optional .caffe.FillerParameter bias_filler = 6; + if (has_bias_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, *this->bias_filler_, output); + } + + // optional uint32 pad = 7 [default = 0]; + if (has_pad()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->pad(), output); + } + + // optional uint32 kernelsize = 8; + if (has_kernelsize()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->kernelsize(), output); + } + + // optional uint32 group = 9 [default = 1]; + if (has_group()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->group(), output); + } + + // optional uint32 stride = 10 [default = 1]; + if (has_stride()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->stride(), output); + } + + // optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + if (has_pool()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 11, this->pool(), output); + } + + // optional float dropout_ratio = 12 [default = 0.5]; + if (has_dropout_ratio()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->dropout_ratio(), output); + } + + // optional uint32 local_size = 13 [default = 5]; + if (has_local_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->local_size(), output); + } + + // optional float alpha = 14 [default = 1]; + if (has_alpha()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(14, this->alpha(), output); + } + + // optional float beta = 15 [default = 0.75]; + if (has_beta()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(15, this->beta(), output); + } + + // optional string source = 16; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.source"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 16, this->source(), output); + } + + // optional float scale = 17 [default = 1]; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(17, this->scale(), output); + } + + // optional string meanfile = 18; + if (has_meanfile()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->meanfile().data(), this->meanfile().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.meanfile"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 18, this->meanfile(), output); + } + + // optional uint32 batchsize = 19; + if (has_batchsize()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(19, this->batchsize(), output); + } + + // optional uint32 cropsize = 20 [default = 0]; + if (has_cropsize()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(20, this->cropsize(), output); + } + + // optional bool mirror = 21 [default = false]; + if (has_mirror()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(21, this->mirror(), output); + } + + // optional float k = 22 [default = 1]; + if (has_k()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(22, this->k(), output); + } + + // repeated .caffe.BlobProto blobs = 50; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 50, this->blobs(i), output); + } + + // repeated float blobs_lr = 51; + for (int i = 0; i < this->blobs_lr_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 51, this->blobs_lr(i), output); + } + + // repeated float weight_decay = 52; + for (int i = 0; i < this->weight_decay_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 52, this->weight_decay(i), output); + } + + // optional uint32 rand_skip = 53 [default = 0]; + if (has_rand_skip()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(53, this->rand_skip(), output); + } + + // optional float det_fg_threshold = 54 [default = 0.5]; + if (has_det_fg_threshold()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(54, this->det_fg_threshold(), output); + } + + // optional float det_bg_threshold = 55 [default = 0.5]; + if (has_det_bg_threshold()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(55, this->det_bg_threshold(), output); + } + + // optional float det_fg_fraction = 56 [default = 0.25]; + if (has_det_fg_fraction()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(56, this->det_fg_fraction(), output); + } + + // optional uint32 det_context_pad = 58 [default = 0]; + if (has_det_context_pad()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(58, this->det_context_pad(), output); + } + + // optional string det_crop_mode = 59 [default = "warp"]; + if (has_det_crop_mode()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->det_crop_mode().data(), this->det_crop_mode().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.det_crop_mode"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 59, this->det_crop_mode(), output); + } + + // optional int32 new_num = 60 [default = 0]; + if (has_new_num()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(60, this->new_num(), output); + } + + // optional int32 new_channels = 61 [default = 0]; + if (has_new_channels()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(61, this->new_channels(), output); + } + + // optional int32 new_height = 62 [default = 0]; + if (has_new_height()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(62, this->new_height(), output); + } + + // optional int32 new_width = 63 [default = 0]; + if (has_new_width()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(63, this->new_width(), output); + } + + // optional bool shuffle_images = 64 [default = false]; + if (has_shuffle_images()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(64, this->shuffle_images(), output); + } + + // optional uint32 concat_dim = 65 [default = 1]; + if (has_concat_dim()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(65, this->concat_dim(), output); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 1001; + if (has_hdf5_output_param()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1001, *this->hdf5_output_param_, output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.V0LayerParameter) +} + +::google::protobuf::uint8* V0LayerParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.V0LayerParameter) + // optional string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional string type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->type(), target); + } + + // optional uint32 num_output = 3; + if (has_num_output()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->num_output(), target); + } + + // optional bool biasterm = 4 [default = true]; + if (has_biasterm()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->biasterm(), target); + } + + // optional .caffe.FillerParameter weight_filler = 5; + if (has_weight_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *this->weight_filler_, false, target); + } + + // optional .caffe.FillerParameter bias_filler = 6; + if (has_bias_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 6, *this->bias_filler_, false, target); + } + + // optional uint32 pad = 7 [default = 0]; + if (has_pad()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->pad(), target); + } + + // optional uint32 kernelsize = 8; + if (has_kernelsize()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->kernelsize(), target); + } + + // optional uint32 group = 9 [default = 1]; + if (has_group()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->group(), target); + } + + // optional uint32 stride = 10 [default = 1]; + if (has_stride()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->stride(), target); + } + + // optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + if (has_pool()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 11, this->pool(), target); + } + + // optional float dropout_ratio = 12 [default = 0.5]; + if (has_dropout_ratio()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->dropout_ratio(), target); + } + + // optional uint32 local_size = 13 [default = 5]; + if (has_local_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->local_size(), target); + } + + // optional float alpha = 14 [default = 1]; + if (has_alpha()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(14, this->alpha(), target); + } + + // optional float beta = 15 [default = 0.75]; + if (has_beta()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(15, this->beta(), target); + } + + // optional string source = 16; + if (has_source()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->source().data(), this->source().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.source"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 16, this->source(), target); + } + + // optional float scale = 17 [default = 1]; + if (has_scale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(17, this->scale(), target); + } + + // optional string meanfile = 18; + if (has_meanfile()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->meanfile().data(), this->meanfile().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.meanfile"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 18, this->meanfile(), target); + } + + // optional uint32 batchsize = 19; + if (has_batchsize()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(19, this->batchsize(), target); + } + + // optional uint32 cropsize = 20 [default = 0]; + if (has_cropsize()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(20, this->cropsize(), target); + } + + // optional bool mirror = 21 [default = false]; + if (has_mirror()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(21, this->mirror(), target); + } + + // optional float k = 22 [default = 1]; + if (has_k()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(22, this->k(), target); + } + + // repeated .caffe.BlobProto blobs = 50; + for (unsigned int i = 0, n = this->blobs_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 50, this->blobs(i), false, target); + } + + // repeated float blobs_lr = 51; + for (int i = 0; i < this->blobs_lr_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(51, this->blobs_lr(i), target); + } + + // repeated float weight_decay = 52; + for (int i = 0; i < this->weight_decay_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(52, this->weight_decay(i), target); + } + + // optional uint32 rand_skip = 53 [default = 0]; + if (has_rand_skip()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(53, this->rand_skip(), target); + } + + // optional float det_fg_threshold = 54 [default = 0.5]; + if (has_det_fg_threshold()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(54, this->det_fg_threshold(), target); + } + + // optional float det_bg_threshold = 55 [default = 0.5]; + if (has_det_bg_threshold()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(55, this->det_bg_threshold(), target); + } + + // optional float det_fg_fraction = 56 [default = 0.25]; + if (has_det_fg_fraction()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(56, this->det_fg_fraction(), target); + } + + // optional uint32 det_context_pad = 58 [default = 0]; + if (has_det_context_pad()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(58, this->det_context_pad(), target); + } + + // optional string det_crop_mode = 59 [default = "warp"]; + if (has_det_crop_mode()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->det_crop_mode().data(), this->det_crop_mode().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "caffe.V0LayerParameter.det_crop_mode"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 59, this->det_crop_mode(), target); + } + + // optional int32 new_num = 60 [default = 0]; + if (has_new_num()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(60, this->new_num(), target); + } + + // optional int32 new_channels = 61 [default = 0]; + if (has_new_channels()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(61, this->new_channels(), target); + } + + // optional int32 new_height = 62 [default = 0]; + if (has_new_height()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(62, this->new_height(), target); + } + + // optional int32 new_width = 63 [default = 0]; + if (has_new_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(63, this->new_width(), target); + } + + // optional bool shuffle_images = 64 [default = false]; + if (has_shuffle_images()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(64, this->shuffle_images(), target); + } + + // optional uint32 concat_dim = 65 [default = 1]; + if (has_concat_dim()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(65, this->concat_dim(), target); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 1001; + if (has_hdf5_output_param()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1001, *this->hdf5_output_param_, false, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.V0LayerParameter) + return target; +} + +size_t V0LayerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.V0LayerParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string type = 2; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + // optional uint32 num_output = 3; + if (has_num_output()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->num_output()); + } + + // optional bool biasterm = 4 [default = true]; + if (has_biasterm()) { + total_size += 1 + 1; + } + + // optional .caffe.FillerParameter weight_filler = 5; + if (has_weight_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->weight_filler_); + } + + // optional .caffe.FillerParameter bias_filler = 6; + if (has_bias_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->bias_filler_); + } + + // optional uint32 pad = 7 [default = 0]; + if (has_pad()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->pad()); + } + + // optional uint32 kernelsize = 8; + if (has_kernelsize()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->kernelsize()); + } + + } + if (_has_bits_[8 / 32] & 65280u) { + // optional uint32 group = 9 [default = 1]; + if (has_group()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->group()); + } + + // optional uint32 stride = 10 [default = 1]; + if (has_stride()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stride()); + } + + // optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + if (has_pool()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->pool()); + } + + // optional float dropout_ratio = 12 [default = 0.5]; + if (has_dropout_ratio()) { + total_size += 1 + 4; + } + + // optional uint32 local_size = 13 [default = 5]; + if (has_local_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->local_size()); + } + + // optional float alpha = 14 [default = 1]; + if (has_alpha()) { + total_size += 1 + 4; + } + + // optional float beta = 15 [default = 0.75]; + if (has_beta()) { + total_size += 1 + 4; + } + + // optional float k = 22 [default = 1]; + if (has_k()) { + total_size += 2 + 4; + } + + } + if (_has_bits_[16 / 32] & 4128768u) { + // optional string source = 16; + if (has_source()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->source()); + } + + // optional float scale = 17 [default = 1]; + if (has_scale()) { + total_size += 2 + 4; + } + + // optional string meanfile = 18; + if (has_meanfile()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->meanfile()); + } + + // optional uint32 batchsize = 19; + if (has_batchsize()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->batchsize()); + } + + // optional uint32 cropsize = 20 [default = 0]; + if (has_cropsize()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->cropsize()); + } + + // optional bool mirror = 21 [default = false]; + if (has_mirror()) { + total_size += 2 + 1; + } + + } + if (_has_bits_[25 / 32] & 4261412864u) { + // optional uint32 rand_skip = 53 [default = 0]; + if (has_rand_skip()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->rand_skip()); + } + + // optional float det_fg_threshold = 54 [default = 0.5]; + if (has_det_fg_threshold()) { + total_size += 2 + 4; + } + + // optional float det_bg_threshold = 55 [default = 0.5]; + if (has_det_bg_threshold()) { + total_size += 2 + 4; + } + + // optional float det_fg_fraction = 56 [default = 0.25]; + if (has_det_fg_fraction()) { + total_size += 2 + 4; + } + + // optional uint32 det_context_pad = 58 [default = 0]; + if (has_det_context_pad()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->det_context_pad()); + } + + // optional string det_crop_mode = 59 [default = "warp"]; + if (has_det_crop_mode()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->det_crop_mode()); + } + + // optional int32 new_num = 60 [default = 0]; + if (has_new_num()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->new_num()); + } + + } + if (_has_bits_[32 / 32] & 63u) { + // optional int32 new_channels = 61 [default = 0]; + if (has_new_channels()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->new_channels()); + } + + // optional int32 new_height = 62 [default = 0]; + if (has_new_height()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->new_height()); + } + + // optional int32 new_width = 63 [default = 0]; + if (has_new_width()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->new_width()); + } + + // optional bool shuffle_images = 64 [default = false]; + if (has_shuffle_images()) { + total_size += 2 + 1; + } + + // optional uint32 concat_dim = 65 [default = 1]; + if (has_concat_dim()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->concat_dim()); + } + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 1001; + if (has_hdf5_output_param()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->hdf5_output_param_); + } + + } + // repeated .caffe.BlobProto blobs = 50; + { + unsigned int count = this->blobs_size(); + total_size += 2UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blobs(i)); + } + } + + // repeated float blobs_lr = 51; + { + size_t data_size = 0; + unsigned int count = this->blobs_lr_size(); + data_size = 4UL * count; + total_size += 2 * + ::google::protobuf::internal::FromIntSize(this->blobs_lr_size()); + total_size += data_size; + } + + // repeated float weight_decay = 52; + { + size_t data_size = 0; + unsigned int count = this->weight_decay_size(); + data_size = 4UL * count; + total_size += 2 * + ::google::protobuf::internal::FromIntSize(this->weight_decay_size()); + total_size += data_size; + } + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void V0LayerParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.V0LayerParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const V0LayerParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.V0LayerParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.V0LayerParameter) + UnsafeMergeFrom(*source); + } +} + +void V0LayerParameter::MergeFrom(const V0LayerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.V0LayerParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void V0LayerParameter::UnsafeMergeFrom(const V0LayerParameter& from) { + GOOGLE_DCHECK(&from != this); + blobs_.MergeFrom(from.blobs_); + blobs_lr_.UnsafeMergeFrom(from.blobs_lr_); + weight_decay_.UnsafeMergeFrom(from.weight_decay_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_type()) { + set_has_type(); + type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_); + } + if (from.has_num_output()) { + set_num_output(from.num_output()); + } + if (from.has_biasterm()) { + set_biasterm(from.biasterm()); + } + if (from.has_weight_filler()) { + mutable_weight_filler()->::caffe::FillerParameter::MergeFrom(from.weight_filler()); + } + if (from.has_bias_filler()) { + mutable_bias_filler()->::caffe::FillerParameter::MergeFrom(from.bias_filler()); + } + if (from.has_pad()) { + set_pad(from.pad()); + } + if (from.has_kernelsize()) { + set_kernelsize(from.kernelsize()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_group()) { + set_group(from.group()); + } + if (from.has_stride()) { + set_stride(from.stride()); + } + if (from.has_pool()) { + set_pool(from.pool()); + } + if (from.has_dropout_ratio()) { + set_dropout_ratio(from.dropout_ratio()); + } + if (from.has_local_size()) { + set_local_size(from.local_size()); + } + if (from.has_alpha()) { + set_alpha(from.alpha()); + } + if (from.has_beta()) { + set_beta(from.beta()); + } + if (from.has_k()) { + set_k(from.k()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from.has_source()) { + set_has_source(); + source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_); + } + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_meanfile()) { + set_has_meanfile(); + meanfile_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.meanfile_); + } + if (from.has_batchsize()) { + set_batchsize(from.batchsize()); + } + if (from.has_cropsize()) { + set_cropsize(from.cropsize()); + } + if (from.has_mirror()) { + set_mirror(from.mirror()); + } + } + if (from._has_bits_[25 / 32] & (0xffu << (25 % 32))) { + if (from.has_rand_skip()) { + set_rand_skip(from.rand_skip()); + } + if (from.has_det_fg_threshold()) { + set_det_fg_threshold(from.det_fg_threshold()); + } + if (from.has_det_bg_threshold()) { + set_det_bg_threshold(from.det_bg_threshold()); + } + if (from.has_det_fg_fraction()) { + set_det_fg_fraction(from.det_fg_fraction()); + } + if (from.has_det_context_pad()) { + set_det_context_pad(from.det_context_pad()); + } + if (from.has_det_crop_mode()) { + set_has_det_crop_mode(); + det_crop_mode_.AssignWithDefault(_default_det_crop_mode_, from.det_crop_mode_); + } + if (from.has_new_num()) { + set_new_num(from.new_num()); + } + } + if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) { + if (from.has_new_channels()) { + set_new_channels(from.new_channels()); + } + if (from.has_new_height()) { + set_new_height(from.new_height()); + } + if (from.has_new_width()) { + set_new_width(from.new_width()); + } + if (from.has_shuffle_images()) { + set_shuffle_images(from.shuffle_images()); + } + if (from.has_concat_dim()) { + set_concat_dim(from.concat_dim()); + } + if (from.has_hdf5_output_param()) { + mutable_hdf5_output_param()->::caffe::HDF5OutputParameter::MergeFrom(from.hdf5_output_param()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void V0LayerParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.V0LayerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void V0LayerParameter::CopyFrom(const V0LayerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.V0LayerParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool V0LayerParameter::IsInitialized() const { + + return true; +} + +void V0LayerParameter::Swap(V0LayerParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void V0LayerParameter::InternalSwap(V0LayerParameter* other) { + name_.Swap(&other->name_); + type_.Swap(&other->type_); + std::swap(num_output_, other->num_output_); + std::swap(biasterm_, other->biasterm_); + std::swap(weight_filler_, other->weight_filler_); + std::swap(bias_filler_, other->bias_filler_); + std::swap(pad_, other->pad_); + std::swap(kernelsize_, other->kernelsize_); + std::swap(group_, other->group_); + std::swap(stride_, other->stride_); + std::swap(pool_, other->pool_); + std::swap(dropout_ratio_, other->dropout_ratio_); + std::swap(local_size_, other->local_size_); + std::swap(alpha_, other->alpha_); + std::swap(beta_, other->beta_); + std::swap(k_, other->k_); + source_.Swap(&other->source_); + std::swap(scale_, other->scale_); + meanfile_.Swap(&other->meanfile_); + std::swap(batchsize_, other->batchsize_); + std::swap(cropsize_, other->cropsize_); + std::swap(mirror_, other->mirror_); + blobs_.UnsafeArenaSwap(&other->blobs_); + blobs_lr_.UnsafeArenaSwap(&other->blobs_lr_); + weight_decay_.UnsafeArenaSwap(&other->weight_decay_); + std::swap(rand_skip_, other->rand_skip_); + std::swap(det_fg_threshold_, other->det_fg_threshold_); + std::swap(det_bg_threshold_, other->det_bg_threshold_); + std::swap(det_fg_fraction_, other->det_fg_fraction_); + std::swap(det_context_pad_, other->det_context_pad_); + det_crop_mode_.Swap(&other->det_crop_mode_); + std::swap(new_num_, other->new_num_); + std::swap(new_channels_, other->new_channels_); + std::swap(new_height_, other->new_height_); + std::swap(new_width_, other->new_width_); + std::swap(shuffle_images_, other->shuffle_images_); + std::swap(concat_dim_, other->concat_dim_); + std::swap(hdf5_output_param_, other->hdf5_output_param_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_has_bits_[1], other->_has_bits_[1]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata V0LayerParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = V0LayerParameter_descriptor_; + metadata.reflection = V0LayerParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// V0LayerParameter + +// optional string name = 1; +bool V0LayerParameter::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void V0LayerParameter::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +void V0LayerParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +void V0LayerParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +const ::std::string& V0LayerParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.name) +} +void V0LayerParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.name) +} +void V0LayerParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.name) +} +::std::string* V0LayerParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* V0LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.name) +} + +// optional string type = 2; +bool V0LayerParameter::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void V0LayerParameter::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +void V0LayerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +void V0LayerParameter::clear_type() { + type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_type(); +} +const ::std::string& V0LayerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.type) + return type_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.type) +} +void V0LayerParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.type) +} +void V0LayerParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.type) +} +::std::string* V0LayerParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.type) + return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* V0LayerParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.type) +} + +// optional uint32 num_output = 3; +bool V0LayerParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void V0LayerParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000004u; +} +void V0LayerParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000004u; +} +void V0LayerParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +::google::protobuf::uint32 V0LayerParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.num_output) + return num_output_; +} +void V0LayerParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.num_output) +} + +// optional bool biasterm = 4 [default = true]; +bool V0LayerParameter::has_biasterm() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void V0LayerParameter::set_has_biasterm() { + _has_bits_[0] |= 0x00000008u; +} +void V0LayerParameter::clear_has_biasterm() { + _has_bits_[0] &= ~0x00000008u; +} +void V0LayerParameter::clear_biasterm() { + biasterm_ = true; + clear_has_biasterm(); +} +bool V0LayerParameter::biasterm() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.biasterm) + return biasterm_; +} +void V0LayerParameter::set_biasterm(bool value) { + set_has_biasterm(); + biasterm_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.biasterm) +} + +// optional .caffe.FillerParameter weight_filler = 5; +bool V0LayerParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void V0LayerParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000010u; +} +void V0LayerParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000010u; +} +void V0LayerParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +const ::caffe::FillerParameter& V0LayerParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* V0LayerParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.weight_filler) + return weight_filler_; +} +::caffe::FillerParameter* V0LayerParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +void V0LayerParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 6; +bool V0LayerParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void V0LayerParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000020u; +} +void V0LayerParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000020u; +} +void V0LayerParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +const ::caffe::FillerParameter& V0LayerParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* V0LayerParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.bias_filler) + return bias_filler_; +} +::caffe::FillerParameter* V0LayerParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +void V0LayerParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.bias_filler) +} + +// optional uint32 pad = 7 [default = 0]; +bool V0LayerParameter::has_pad() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void V0LayerParameter::set_has_pad() { + _has_bits_[0] |= 0x00000040u; +} +void V0LayerParameter::clear_has_pad() { + _has_bits_[0] &= ~0x00000040u; +} +void V0LayerParameter::clear_pad() { + pad_ = 0u; + clear_has_pad(); +} +::google::protobuf::uint32 V0LayerParameter::pad() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.pad) + return pad_; +} +void V0LayerParameter::set_pad(::google::protobuf::uint32 value) { + set_has_pad(); + pad_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.pad) +} + +// optional uint32 kernelsize = 8; +bool V0LayerParameter::has_kernelsize() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void V0LayerParameter::set_has_kernelsize() { + _has_bits_[0] |= 0x00000080u; +} +void V0LayerParameter::clear_has_kernelsize() { + _has_bits_[0] &= ~0x00000080u; +} +void V0LayerParameter::clear_kernelsize() { + kernelsize_ = 0u; + clear_has_kernelsize(); +} +::google::protobuf::uint32 V0LayerParameter::kernelsize() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.kernelsize) + return kernelsize_; +} +void V0LayerParameter::set_kernelsize(::google::protobuf::uint32 value) { + set_has_kernelsize(); + kernelsize_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.kernelsize) +} + +// optional uint32 group = 9 [default = 1]; +bool V0LayerParameter::has_group() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +void V0LayerParameter::set_has_group() { + _has_bits_[0] |= 0x00000100u; +} +void V0LayerParameter::clear_has_group() { + _has_bits_[0] &= ~0x00000100u; +} +void V0LayerParameter::clear_group() { + group_ = 1u; + clear_has_group(); +} +::google::protobuf::uint32 V0LayerParameter::group() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.group) + return group_; +} +void V0LayerParameter::set_group(::google::protobuf::uint32 value) { + set_has_group(); + group_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.group) +} + +// optional uint32 stride = 10 [default = 1]; +bool V0LayerParameter::has_stride() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +void V0LayerParameter::set_has_stride() { + _has_bits_[0] |= 0x00000200u; +} +void V0LayerParameter::clear_has_stride() { + _has_bits_[0] &= ~0x00000200u; +} +void V0LayerParameter::clear_stride() { + stride_ = 1u; + clear_has_stride(); +} +::google::protobuf::uint32 V0LayerParameter::stride() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.stride) + return stride_; +} +void V0LayerParameter::set_stride(::google::protobuf::uint32 value) { + set_has_stride(); + stride_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.stride) +} + +// optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; +bool V0LayerParameter::has_pool() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +void V0LayerParameter::set_has_pool() { + _has_bits_[0] |= 0x00000400u; +} +void V0LayerParameter::clear_has_pool() { + _has_bits_[0] &= ~0x00000400u; +} +void V0LayerParameter::clear_pool() { + pool_ = 0; + clear_has_pool(); +} +::caffe::V0LayerParameter_PoolMethod V0LayerParameter::pool() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.pool) + return static_cast< ::caffe::V0LayerParameter_PoolMethod >(pool_); +} +void V0LayerParameter::set_pool(::caffe::V0LayerParameter_PoolMethod value) { + assert(::caffe::V0LayerParameter_PoolMethod_IsValid(value)); + set_has_pool(); + pool_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.pool) +} + +// optional float dropout_ratio = 12 [default = 0.5]; +bool V0LayerParameter::has_dropout_ratio() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +void V0LayerParameter::set_has_dropout_ratio() { + _has_bits_[0] |= 0x00000800u; +} +void V0LayerParameter::clear_has_dropout_ratio() { + _has_bits_[0] &= ~0x00000800u; +} +void V0LayerParameter::clear_dropout_ratio() { + dropout_ratio_ = 0.5f; + clear_has_dropout_ratio(); +} +float V0LayerParameter::dropout_ratio() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.dropout_ratio) + return dropout_ratio_; +} +void V0LayerParameter::set_dropout_ratio(float value) { + set_has_dropout_ratio(); + dropout_ratio_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.dropout_ratio) +} + +// optional uint32 local_size = 13 [default = 5]; +bool V0LayerParameter::has_local_size() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +void V0LayerParameter::set_has_local_size() { + _has_bits_[0] |= 0x00001000u; +} +void V0LayerParameter::clear_has_local_size() { + _has_bits_[0] &= ~0x00001000u; +} +void V0LayerParameter::clear_local_size() { + local_size_ = 5u; + clear_has_local_size(); +} +::google::protobuf::uint32 V0LayerParameter::local_size() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.local_size) + return local_size_; +} +void V0LayerParameter::set_local_size(::google::protobuf::uint32 value) { + set_has_local_size(); + local_size_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.local_size) +} + +// optional float alpha = 14 [default = 1]; +bool V0LayerParameter::has_alpha() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +void V0LayerParameter::set_has_alpha() { + _has_bits_[0] |= 0x00002000u; +} +void V0LayerParameter::clear_has_alpha() { + _has_bits_[0] &= ~0x00002000u; +} +void V0LayerParameter::clear_alpha() { + alpha_ = 1; + clear_has_alpha(); +} +float V0LayerParameter::alpha() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.alpha) + return alpha_; +} +void V0LayerParameter::set_alpha(float value) { + set_has_alpha(); + alpha_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.alpha) +} + +// optional float beta = 15 [default = 0.75]; +bool V0LayerParameter::has_beta() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +void V0LayerParameter::set_has_beta() { + _has_bits_[0] |= 0x00004000u; +} +void V0LayerParameter::clear_has_beta() { + _has_bits_[0] &= ~0x00004000u; +} +void V0LayerParameter::clear_beta() { + beta_ = 0.75f; + clear_has_beta(); +} +float V0LayerParameter::beta() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.beta) + return beta_; +} +void V0LayerParameter::set_beta(float value) { + set_has_beta(); + beta_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.beta) +} + +// optional float k = 22 [default = 1]; +bool V0LayerParameter::has_k() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +void V0LayerParameter::set_has_k() { + _has_bits_[0] |= 0x00008000u; +} +void V0LayerParameter::clear_has_k() { + _has_bits_[0] &= ~0x00008000u; +} +void V0LayerParameter::clear_k() { + k_ = 1; + clear_has_k(); +} +float V0LayerParameter::k() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.k) + return k_; +} +void V0LayerParameter::set_k(float value) { + set_has_k(); + k_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.k) +} + +// optional string source = 16; +bool V0LayerParameter::has_source() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +void V0LayerParameter::set_has_source() { + _has_bits_[0] |= 0x00010000u; +} +void V0LayerParameter::clear_has_source() { + _has_bits_[0] &= ~0x00010000u; +} +void V0LayerParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +const ::std::string& V0LayerParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.source) +} +void V0LayerParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.source) +} +void V0LayerParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.source) +} +::std::string* V0LayerParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* V0LayerParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.source) +} + +// optional float scale = 17 [default = 1]; +bool V0LayerParameter::has_scale() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +void V0LayerParameter::set_has_scale() { + _has_bits_[0] |= 0x00020000u; +} +void V0LayerParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00020000u; +} +void V0LayerParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +float V0LayerParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.scale) + return scale_; +} +void V0LayerParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.scale) +} + +// optional string meanfile = 18; +bool V0LayerParameter::has_meanfile() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +void V0LayerParameter::set_has_meanfile() { + _has_bits_[0] |= 0x00040000u; +} +void V0LayerParameter::clear_has_meanfile() { + _has_bits_[0] &= ~0x00040000u; +} +void V0LayerParameter::clear_meanfile() { + meanfile_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_meanfile(); +} +const ::std::string& V0LayerParameter::meanfile() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.meanfile) + return meanfile_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_meanfile(const ::std::string& value) { + set_has_meanfile(); + meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.meanfile) +} +void V0LayerParameter::set_meanfile(const char* value) { + set_has_meanfile(); + meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.meanfile) +} +void V0LayerParameter::set_meanfile(const char* value, size_t size) { + set_has_meanfile(); + meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.meanfile) +} +::std::string* V0LayerParameter::mutable_meanfile() { + set_has_meanfile(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.meanfile) + return meanfile_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +::std::string* V0LayerParameter::release_meanfile() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.meanfile) + clear_has_meanfile(); + return meanfile_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void V0LayerParameter::set_allocated_meanfile(::std::string* meanfile) { + if (meanfile != NULL) { + set_has_meanfile(); + } else { + clear_has_meanfile(); + } + meanfile_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), meanfile); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.meanfile) +} + +// optional uint32 batchsize = 19; +bool V0LayerParameter::has_batchsize() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +void V0LayerParameter::set_has_batchsize() { + _has_bits_[0] |= 0x00080000u; +} +void V0LayerParameter::clear_has_batchsize() { + _has_bits_[0] &= ~0x00080000u; +} +void V0LayerParameter::clear_batchsize() { + batchsize_ = 0u; + clear_has_batchsize(); +} +::google::protobuf::uint32 V0LayerParameter::batchsize() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.batchsize) + return batchsize_; +} +void V0LayerParameter::set_batchsize(::google::protobuf::uint32 value) { + set_has_batchsize(); + batchsize_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.batchsize) +} + +// optional uint32 cropsize = 20 [default = 0]; +bool V0LayerParameter::has_cropsize() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +void V0LayerParameter::set_has_cropsize() { + _has_bits_[0] |= 0x00100000u; +} +void V0LayerParameter::clear_has_cropsize() { + _has_bits_[0] &= ~0x00100000u; +} +void V0LayerParameter::clear_cropsize() { + cropsize_ = 0u; + clear_has_cropsize(); +} +::google::protobuf::uint32 V0LayerParameter::cropsize() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.cropsize) + return cropsize_; +} +void V0LayerParameter::set_cropsize(::google::protobuf::uint32 value) { + set_has_cropsize(); + cropsize_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.cropsize) +} + +// optional bool mirror = 21 [default = false]; +bool V0LayerParameter::has_mirror() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +void V0LayerParameter::set_has_mirror() { + _has_bits_[0] |= 0x00200000u; +} +void V0LayerParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00200000u; +} +void V0LayerParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +bool V0LayerParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.mirror) + return mirror_; +} +void V0LayerParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.mirror) +} + +// repeated .caffe.BlobProto blobs = 50; +int V0LayerParameter::blobs_size() const { + return blobs_.size(); +} +void V0LayerParameter::clear_blobs() { + blobs_.Clear(); +} +const ::caffe::BlobProto& V0LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.blobs) + return blobs_.Get(index); +} +::caffe::BlobProto* V0LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.blobs) + return blobs_.Mutable(index); +} +::caffe::BlobProto* V0LayerParameter::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.V0LayerParameter.blobs) + return blobs_.Add(); +} +::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +V0LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.blobs) + return &blobs_; +} +const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +V0LayerParameter::blobs() const { + // @@protoc_insertion_point(field_list:caffe.V0LayerParameter.blobs) + return blobs_; +} + +// repeated float blobs_lr = 51; +int V0LayerParameter::blobs_lr_size() const { + return blobs_lr_.size(); +} +void V0LayerParameter::clear_blobs_lr() { + blobs_lr_.Clear(); +} +float V0LayerParameter::blobs_lr(int index) const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.blobs_lr) + return blobs_lr_.Get(index); +} +void V0LayerParameter::set_blobs_lr(int index, float value) { + blobs_lr_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.blobs_lr) +} +void V0LayerParameter::add_blobs_lr(float value) { + blobs_lr_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V0LayerParameter.blobs_lr) +} +const ::google::protobuf::RepeatedField< float >& +V0LayerParameter::blobs_lr() const { + // @@protoc_insertion_point(field_list:caffe.V0LayerParameter.blobs_lr) + return blobs_lr_; +} +::google::protobuf::RepeatedField< float >* +V0LayerParameter::mutable_blobs_lr() { + // @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.blobs_lr) + return &blobs_lr_; +} + +// repeated float weight_decay = 52; +int V0LayerParameter::weight_decay_size() const { + return weight_decay_.size(); +} +void V0LayerParameter::clear_weight_decay() { + weight_decay_.Clear(); +} +float V0LayerParameter::weight_decay(int index) const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.weight_decay) + return weight_decay_.Get(index); +} +void V0LayerParameter::set_weight_decay(int index, float value) { + weight_decay_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.weight_decay) +} +void V0LayerParameter::add_weight_decay(float value) { + weight_decay_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V0LayerParameter.weight_decay) +} +const ::google::protobuf::RepeatedField< float >& +V0LayerParameter::weight_decay() const { + // @@protoc_insertion_point(field_list:caffe.V0LayerParameter.weight_decay) + return weight_decay_; +} +::google::protobuf::RepeatedField< float >* +V0LayerParameter::mutable_weight_decay() { + // @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.weight_decay) + return &weight_decay_; +} + +// optional uint32 rand_skip = 53 [default = 0]; +bool V0LayerParameter::has_rand_skip() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +void V0LayerParameter::set_has_rand_skip() { + _has_bits_[0] |= 0x02000000u; +} +void V0LayerParameter::clear_has_rand_skip() { + _has_bits_[0] &= ~0x02000000u; +} +void V0LayerParameter::clear_rand_skip() { + rand_skip_ = 0u; + clear_has_rand_skip(); +} +::google::protobuf::uint32 V0LayerParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.rand_skip) + return rand_skip_; +} +void V0LayerParameter::set_rand_skip(::google::protobuf::uint32 value) { + set_has_rand_skip(); + rand_skip_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.rand_skip) +} + +// optional float det_fg_threshold = 54 [default = 0.5]; +bool V0LayerParameter::has_det_fg_threshold() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +void V0LayerParameter::set_has_det_fg_threshold() { + _has_bits_[0] |= 0x04000000u; +} +void V0LayerParameter::clear_has_det_fg_threshold() { + _has_bits_[0] &= ~0x04000000u; +} +void V0LayerParameter::clear_det_fg_threshold() { + det_fg_threshold_ = 0.5f; + clear_has_det_fg_threshold(); +} +float V0LayerParameter::det_fg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_fg_threshold) + return det_fg_threshold_; +} +void V0LayerParameter::set_det_fg_threshold(float value) { + set_has_det_fg_threshold(); + det_fg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_fg_threshold) +} + +// optional float det_bg_threshold = 55 [default = 0.5]; +bool V0LayerParameter::has_det_bg_threshold() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +void V0LayerParameter::set_has_det_bg_threshold() { + _has_bits_[0] |= 0x08000000u; +} +void V0LayerParameter::clear_has_det_bg_threshold() { + _has_bits_[0] &= ~0x08000000u; +} +void V0LayerParameter::clear_det_bg_threshold() { + det_bg_threshold_ = 0.5f; + clear_has_det_bg_threshold(); +} +float V0LayerParameter::det_bg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_bg_threshold) + return det_bg_threshold_; +} +void V0LayerParameter::set_det_bg_threshold(float value) { + set_has_det_bg_threshold(); + det_bg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_bg_threshold) +} + +// optional float det_fg_fraction = 56 [default = 0.25]; +bool V0LayerParameter::has_det_fg_fraction() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +void V0LayerParameter::set_has_det_fg_fraction() { + _has_bits_[0] |= 0x10000000u; +} +void V0LayerParameter::clear_has_det_fg_fraction() { + _has_bits_[0] &= ~0x10000000u; +} +void V0LayerParameter::clear_det_fg_fraction() { + det_fg_fraction_ = 0.25f; + clear_has_det_fg_fraction(); +} +float V0LayerParameter::det_fg_fraction() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_fg_fraction) + return det_fg_fraction_; +} +void V0LayerParameter::set_det_fg_fraction(float value) { + set_has_det_fg_fraction(); + det_fg_fraction_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_fg_fraction) +} + +// optional uint32 det_context_pad = 58 [default = 0]; +bool V0LayerParameter::has_det_context_pad() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +void V0LayerParameter::set_has_det_context_pad() { + _has_bits_[0] |= 0x20000000u; +} +void V0LayerParameter::clear_has_det_context_pad() { + _has_bits_[0] &= ~0x20000000u; +} +void V0LayerParameter::clear_det_context_pad() { + det_context_pad_ = 0u; + clear_has_det_context_pad(); +} +::google::protobuf::uint32 V0LayerParameter::det_context_pad() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_context_pad) + return det_context_pad_; +} +void V0LayerParameter::set_det_context_pad(::google::protobuf::uint32 value) { + set_has_det_context_pad(); + det_context_pad_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_context_pad) +} + +// optional string det_crop_mode = 59 [default = "warp"]; +bool V0LayerParameter::has_det_crop_mode() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +void V0LayerParameter::set_has_det_crop_mode() { + _has_bits_[0] |= 0x40000000u; +} +void V0LayerParameter::clear_has_det_crop_mode() { + _has_bits_[0] &= ~0x40000000u; +} +void V0LayerParameter::clear_det_crop_mode() { + det_crop_mode_.ClearToDefaultNoArena(_default_det_crop_mode_); + clear_has_det_crop_mode(); +} +const ::std::string& V0LayerParameter::det_crop_mode() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_crop_mode) + return det_crop_mode_.GetNoArena(_default_det_crop_mode_); +} +void V0LayerParameter::set_det_crop_mode(const ::std::string& value) { + set_has_det_crop_mode(); + det_crop_mode_.SetNoArena(_default_det_crop_mode_, value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_crop_mode) +} +void V0LayerParameter::set_det_crop_mode(const char* value) { + set_has_det_crop_mode(); + det_crop_mode_.SetNoArena(_default_det_crop_mode_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.det_crop_mode) +} +void V0LayerParameter::set_det_crop_mode(const char* value, size_t size) { + set_has_det_crop_mode(); + det_crop_mode_.SetNoArena(_default_det_crop_mode_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.det_crop_mode) +} +::std::string* V0LayerParameter::mutable_det_crop_mode() { + set_has_det_crop_mode(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.det_crop_mode) + return det_crop_mode_.MutableNoArena(_default_det_crop_mode_); +} +::std::string* V0LayerParameter::release_det_crop_mode() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.det_crop_mode) + clear_has_det_crop_mode(); + return det_crop_mode_.ReleaseNoArena(_default_det_crop_mode_); +} +void V0LayerParameter::set_allocated_det_crop_mode(::std::string* det_crop_mode) { + if (det_crop_mode != NULL) { + set_has_det_crop_mode(); + } else { + clear_has_det_crop_mode(); + } + det_crop_mode_.SetAllocatedNoArena(_default_det_crop_mode_, det_crop_mode); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.det_crop_mode) +} + +// optional int32 new_num = 60 [default = 0]; +bool V0LayerParameter::has_new_num() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +void V0LayerParameter::set_has_new_num() { + _has_bits_[0] |= 0x80000000u; +} +void V0LayerParameter::clear_has_new_num() { + _has_bits_[0] &= ~0x80000000u; +} +void V0LayerParameter::clear_new_num() { + new_num_ = 0; + clear_has_new_num(); +} +::google::protobuf::int32 V0LayerParameter::new_num() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_num) + return new_num_; +} +void V0LayerParameter::set_new_num(::google::protobuf::int32 value) { + set_has_new_num(); + new_num_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_num) +} + +// optional int32 new_channels = 61 [default = 0]; +bool V0LayerParameter::has_new_channels() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +void V0LayerParameter::set_has_new_channels() { + _has_bits_[1] |= 0x00000001u; +} +void V0LayerParameter::clear_has_new_channels() { + _has_bits_[1] &= ~0x00000001u; +} +void V0LayerParameter::clear_new_channels() { + new_channels_ = 0; + clear_has_new_channels(); +} +::google::protobuf::int32 V0LayerParameter::new_channels() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_channels) + return new_channels_; +} +void V0LayerParameter::set_new_channels(::google::protobuf::int32 value) { + set_has_new_channels(); + new_channels_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_channels) +} + +// optional int32 new_height = 62 [default = 0]; +bool V0LayerParameter::has_new_height() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +void V0LayerParameter::set_has_new_height() { + _has_bits_[1] |= 0x00000002u; +} +void V0LayerParameter::clear_has_new_height() { + _has_bits_[1] &= ~0x00000002u; +} +void V0LayerParameter::clear_new_height() { + new_height_ = 0; + clear_has_new_height(); +} +::google::protobuf::int32 V0LayerParameter::new_height() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_height) + return new_height_; +} +void V0LayerParameter::set_new_height(::google::protobuf::int32 value) { + set_has_new_height(); + new_height_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_height) +} + +// optional int32 new_width = 63 [default = 0]; +bool V0LayerParameter::has_new_width() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +void V0LayerParameter::set_has_new_width() { + _has_bits_[1] |= 0x00000004u; +} +void V0LayerParameter::clear_has_new_width() { + _has_bits_[1] &= ~0x00000004u; +} +void V0LayerParameter::clear_new_width() { + new_width_ = 0; + clear_has_new_width(); +} +::google::protobuf::int32 V0LayerParameter::new_width() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_width) + return new_width_; +} +void V0LayerParameter::set_new_width(::google::protobuf::int32 value) { + set_has_new_width(); + new_width_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_width) +} + +// optional bool shuffle_images = 64 [default = false]; +bool V0LayerParameter::has_shuffle_images() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +void V0LayerParameter::set_has_shuffle_images() { + _has_bits_[1] |= 0x00000008u; +} +void V0LayerParameter::clear_has_shuffle_images() { + _has_bits_[1] &= ~0x00000008u; +} +void V0LayerParameter::clear_shuffle_images() { + shuffle_images_ = false; + clear_has_shuffle_images(); +} +bool V0LayerParameter::shuffle_images() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.shuffle_images) + return shuffle_images_; +} +void V0LayerParameter::set_shuffle_images(bool value) { + set_has_shuffle_images(); + shuffle_images_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.shuffle_images) +} + +// optional uint32 concat_dim = 65 [default = 1]; +bool V0LayerParameter::has_concat_dim() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +void V0LayerParameter::set_has_concat_dim() { + _has_bits_[1] |= 0x00000010u; +} +void V0LayerParameter::clear_has_concat_dim() { + _has_bits_[1] &= ~0x00000010u; +} +void V0LayerParameter::clear_concat_dim() { + concat_dim_ = 1u; + clear_has_concat_dim(); +} +::google::protobuf::uint32 V0LayerParameter::concat_dim() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.concat_dim) + return concat_dim_; +} +void V0LayerParameter::set_concat_dim(::google::protobuf::uint32 value) { + set_has_concat_dim(); + concat_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.concat_dim) +} + +// optional .caffe.HDF5OutputParameter hdf5_output_param = 1001; +bool V0LayerParameter::has_hdf5_output_param() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +void V0LayerParameter::set_has_hdf5_output_param() { + _has_bits_[1] |= 0x00000020u; +} +void V0LayerParameter::clear_has_hdf5_output_param() { + _has_bits_[1] &= ~0x00000020u; +} +void V0LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + clear_has_hdf5_output_param(); +} +const ::caffe::HDF5OutputParameter& V0LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.hdf5_output_param) + return hdf5_output_param_ != NULL ? *hdf5_output_param_ + : *::caffe::HDF5OutputParameter::internal_default_instance(); +} +::caffe::HDF5OutputParameter* V0LayerParameter::mutable_hdf5_output_param() { + set_has_hdf5_output_param(); + if (hdf5_output_param_ == NULL) { + hdf5_output_param_ = new ::caffe::HDF5OutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.hdf5_output_param) + return hdf5_output_param_; +} +::caffe::HDF5OutputParameter* V0LayerParameter::release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.hdf5_output_param) + clear_has_hdf5_output_param(); + ::caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = NULL; + return temp; +} +void V0LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) { + delete hdf5_output_param_; + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + set_has_hdf5_output_param(); + } else { + clear_has_hdf5_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.hdf5_output_param) +} + +inline const V0LayerParameter* V0LayerParameter::internal_default_instance() { + return &V0LayerParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int PReLUParameter::kFillerFieldNumber; +const int PReLUParameter::kChannelSharedFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +PReLUParameter::PReLUParameter() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.PReLUParameter) +} + +void PReLUParameter::InitAsDefaultInstance() { + filler_ = const_cast< ::caffe::FillerParameter*>( + ::caffe::FillerParameter::internal_default_instance()); +} + +PReLUParameter::PReLUParameter(const PReLUParameter& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.PReLUParameter) +} + +void PReLUParameter::SharedCtor() { + _cached_size_ = 0; + filler_ = NULL; + channel_shared_ = false; +} + +PReLUParameter::~PReLUParameter() { + // @@protoc_insertion_point(destructor:caffe.PReLUParameter) + SharedDtor(); +} + +void PReLUParameter::SharedDtor() { + if (this != &PReLUParameter_default_instance_.get()) { + delete filler_; + } +} + +void PReLUParameter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PReLUParameter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PReLUParameter_descriptor_; +} + +const PReLUParameter& PReLUParameter::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed PReLUParameter_default_instance_; + +PReLUParameter* PReLUParameter::New(::google::protobuf::Arena* arena) const { + PReLUParameter* n = new PReLUParameter; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void PReLUParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.PReLUParameter) + if (_has_bits_[0 / 32] & 3u) { + if (has_filler()) { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + } + channel_shared_ = false; + } + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool PReLUParameter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.PReLUParameter) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .caffe.FillerParameter filler = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_filler())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_channel_shared; + break; + } + + // optional bool channel_shared = 2 [default = false]; + case 2: { + if (tag == 16) { + parse_channel_shared: + set_has_channel_shared(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &channel_shared_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.PReLUParameter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.PReLUParameter) + return false; +#undef DO_ +} + +void PReLUParameter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.PReLUParameter) + // optional .caffe.FillerParameter filler = 1; + if (has_filler()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, *this->filler_, output); + } + + // optional bool channel_shared = 2 [default = false]; + if (has_channel_shared()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->channel_shared(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.PReLUParameter) +} + +::google::protobuf::uint8* PReLUParameter::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.PReLUParameter) + // optional .caffe.FillerParameter filler = 1; + if (has_filler()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, *this->filler_, false, target); + } + + // optional bool channel_shared = 2 [default = false]; + if (has_channel_shared()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->channel_shared(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.PReLUParameter) + return target; +} + +size_t PReLUParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.PReLUParameter) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 3u) { + // optional .caffe.FillerParameter filler = 1; + if (has_filler()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->filler_); + } + + // optional bool channel_shared = 2 [default = false]; + if (has_channel_shared()) { + total_size += 1 + 1; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PReLUParameter::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.PReLUParameter) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const PReLUParameter* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.PReLUParameter) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.PReLUParameter) + UnsafeMergeFrom(*source); + } +} + +void PReLUParameter::MergeFrom(const PReLUParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.PReLUParameter) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void PReLUParameter::UnsafeMergeFrom(const PReLUParameter& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_filler()) { + mutable_filler()->::caffe::FillerParameter::MergeFrom(from.filler()); + } + if (from.has_channel_shared()) { + set_channel_shared(from.channel_shared()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void PReLUParameter::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.PReLUParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PReLUParameter::CopyFrom(const PReLUParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.PReLUParameter) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool PReLUParameter::IsInitialized() const { + + return true; +} + +void PReLUParameter::Swap(PReLUParameter* other) { + if (other == this) return; + InternalSwap(other); +} +void PReLUParameter::InternalSwap(PReLUParameter* other) { + std::swap(filler_, other->filler_); + std::swap(channel_shared_, other->channel_shared_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata PReLUParameter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PReLUParameter_descriptor_; + metadata.reflection = PReLUParameter_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// PReLUParameter + +// optional .caffe.FillerParameter filler = 1; +bool PReLUParameter::has_filler() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void PReLUParameter::set_has_filler() { + _has_bits_[0] |= 0x00000001u; +} +void PReLUParameter::clear_has_filler() { + _has_bits_[0] &= ~0x00000001u; +} +void PReLUParameter::clear_filler() { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + clear_has_filler(); +} +const ::caffe::FillerParameter& PReLUParameter::filler() const { + // @@protoc_insertion_point(field_get:caffe.PReLUParameter.filler) + return filler_ != NULL ? *filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +::caffe::FillerParameter* PReLUParameter::mutable_filler() { + set_has_filler(); + if (filler_ == NULL) { + filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.PReLUParameter.filler) + return filler_; +} +::caffe::FillerParameter* PReLUParameter::release_filler() { + // @@protoc_insertion_point(field_release:caffe.PReLUParameter.filler) + clear_has_filler(); + ::caffe::FillerParameter* temp = filler_; + filler_ = NULL; + return temp; +} +void PReLUParameter::set_allocated_filler(::caffe::FillerParameter* filler) { + delete filler_; + filler_ = filler; + if (filler) { + set_has_filler(); + } else { + clear_has_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.PReLUParameter.filler) +} + +// optional bool channel_shared = 2 [default = false]; +bool PReLUParameter::has_channel_shared() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void PReLUParameter::set_has_channel_shared() { + _has_bits_[0] |= 0x00000002u; +} +void PReLUParameter::clear_has_channel_shared() { + _has_bits_[0] &= ~0x00000002u; +} +void PReLUParameter::clear_channel_shared() { + channel_shared_ = false; + clear_has_channel_shared(); +} +bool PReLUParameter::channel_shared() const { + // @@protoc_insertion_point(field_get:caffe.PReLUParameter.channel_shared) + return channel_shared_; +} +void PReLUParameter::set_channel_shared(bool value) { + set_has_channel_shared(); + channel_shared_ = value; + // @@protoc_insertion_point(field_set:caffe.PReLUParameter.channel_shared) +} + +inline const PReLUParameter* PReLUParameter::internal_default_instance() { + return &PReLUParameter_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NormalizedBBox::kXminFieldNumber; +const int NormalizedBBox::kYminFieldNumber; +const int NormalizedBBox::kXmaxFieldNumber; +const int NormalizedBBox::kYmaxFieldNumber; +const int NormalizedBBox::kLabelFieldNumber; +const int NormalizedBBox::kDifficultFieldNumber; +const int NormalizedBBox::kScoreFieldNumber; +const int NormalizedBBox::kSizeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NormalizedBBox::NormalizedBBox() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_caffe_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:caffe.NormalizedBBox) +} + +void NormalizedBBox::InitAsDefaultInstance() { +} + +NormalizedBBox::NormalizedBBox(const NormalizedBBox& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:caffe.NormalizedBBox) +} + +void NormalizedBBox::SharedCtor() { + _cached_size_ = 0; + ::memset(&xmin_, 0, reinterpret_cast(&size_) - + reinterpret_cast(&xmin_) + sizeof(size_)); +} + +NormalizedBBox::~NormalizedBBox() { + // @@protoc_insertion_point(destructor:caffe.NormalizedBBox) + SharedDtor(); +} + +void NormalizedBBox::SharedDtor() { +} + +void NormalizedBBox::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NormalizedBBox::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NormalizedBBox_descriptor_; +} + +const NormalizedBBox& NormalizedBBox::default_instance() { + protobuf_InitDefaults_caffe_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NormalizedBBox_default_instance_; + +NormalizedBBox* NormalizedBBox::New(::google::protobuf::Arena* arena) const { + NormalizedBBox* n = new NormalizedBBox; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void NormalizedBBox::Clear() { +// @@protoc_insertion_point(message_clear_start:caffe.NormalizedBBox) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(NormalizedBBox, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(xmin_, size_); + +#undef ZR_HELPER_ +#undef ZR_ + + _has_bits_.Clear(); + if (_internal_metadata_.have_unknown_fields()) { + mutable_unknown_fields()->Clear(); + } +} + +bool NormalizedBBox::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:caffe.NormalizedBBox) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional float xmin = 1; + case 1: { + if (tag == 13) { + set_has_xmin(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &xmin_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_ymin; + break; + } + + // optional float ymin = 2; + case 2: { + if (tag == 21) { + parse_ymin: + set_has_ymin(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &ymin_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_xmax; + break; + } + + // optional float xmax = 3; + case 3: { + if (tag == 29) { + parse_xmax: + set_has_xmax(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &xmax_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_ymax; + break; + } + + // optional float ymax = 4; + case 4: { + if (tag == 37) { + parse_ymax: + set_has_ymax(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &ymax_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_label; + break; + } + + // optional int32 label = 5; + case 5: { + if (tag == 40) { + parse_label: + set_has_label(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &label_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_difficult; + break; + } + + // optional bool difficult = 6; + case 6: { + if (tag == 48) { + parse_difficult: + set_has_difficult(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &difficult_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(61)) goto parse_score; + break; + } + + // optional float score = 7; + case 7: { + if (tag == 61) { + parse_score: + set_has_score(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &score_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(69)) goto parse_size; + break; + } + + // optional float size = 8; + case 8: { + if (tag == 69) { + parse_size: + set_has_size(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &size_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:caffe.NormalizedBBox) + return true; +failure: + // @@protoc_insertion_point(parse_failure:caffe.NormalizedBBox) + return false; +#undef DO_ +} + +void NormalizedBBox::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:caffe.NormalizedBBox) + // optional float xmin = 1; + if (has_xmin()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->xmin(), output); + } + + // optional float ymin = 2; + if (has_ymin()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->ymin(), output); + } + + // optional float xmax = 3; + if (has_xmax()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->xmax(), output); + } + + // optional float ymax = 4; + if (has_ymax()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->ymax(), output); + } + + // optional int32 label = 5; + if (has_label()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->label(), output); + } + + // optional bool difficult = 6; + if (has_difficult()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->difficult(), output); + } + + // optional float score = 7; + if (has_score()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->score(), output); + } + + // optional float size = 8; + if (has_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->size(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:caffe.NormalizedBBox) +} + +::google::protobuf::uint8* NormalizedBBox::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:caffe.NormalizedBBox) + // optional float xmin = 1; + if (has_xmin()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->xmin(), target); + } + + // optional float ymin = 2; + if (has_ymin()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->ymin(), target); + } + + // optional float xmax = 3; + if (has_xmax()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->xmax(), target); + } + + // optional float ymax = 4; + if (has_ymax()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->ymax(), target); + } + + // optional int32 label = 5; + if (has_label()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->label(), target); + } + + // optional bool difficult = 6; + if (has_difficult()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->difficult(), target); + } + + // optional float score = 7; + if (has_score()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->score(), target); + } + + // optional float size = 8; + if (has_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->size(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:caffe.NormalizedBBox) + return target; +} + +size_t NormalizedBBox::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:caffe.NormalizedBBox) + size_t total_size = 0; + + if (_has_bits_[0 / 32] & 255u) { + // optional float xmin = 1; + if (has_xmin()) { + total_size += 1 + 4; + } + + // optional float ymin = 2; + if (has_ymin()) { + total_size += 1 + 4; + } + + // optional float xmax = 3; + if (has_xmax()) { + total_size += 1 + 4; + } + + // optional float ymax = 4; + if (has_ymax()) { + total_size += 1 + 4; + } + + // optional int32 label = 5; + if (has_label()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->label()); + } + + // optional bool difficult = 6; + if (has_difficult()) { + total_size += 1 + 1; + } + + // optional float score = 7; + if (has_score()) { + total_size += 1 + 4; + } + + // optional float size = 8; + if (has_size()) { + total_size += 1 + 4; + } + + } + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NormalizedBBox::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:caffe.NormalizedBBox) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NormalizedBBox* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:caffe.NormalizedBBox) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:caffe.NormalizedBBox) + UnsafeMergeFrom(*source); + } +} + +void NormalizedBBox::MergeFrom(const NormalizedBBox& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:caffe.NormalizedBBox) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NormalizedBBox::UnsafeMergeFrom(const NormalizedBBox& from) { + GOOGLE_DCHECK(&from != this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_xmin()) { + set_xmin(from.xmin()); + } + if (from.has_ymin()) { + set_ymin(from.ymin()); + } + if (from.has_xmax()) { + set_xmax(from.xmax()); + } + if (from.has_ymax()) { + set_ymax(from.ymax()); + } + if (from.has_label()) { + set_label(from.label()); + } + if (from.has_difficult()) { + set_difficult(from.difficult()); + } + if (from.has_score()) { + set_score(from.score()); + } + if (from.has_size()) { + set_size(from.size()); + } + } + if (from._internal_metadata_.have_unknown_fields()) { + ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata( + from.unknown_fields(), &_internal_metadata_); + } +} + +void NormalizedBBox::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:caffe.NormalizedBBox) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NormalizedBBox::CopyFrom(const NormalizedBBox& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:caffe.NormalizedBBox) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NormalizedBBox::IsInitialized() const { + + return true; +} + +void NormalizedBBox::Swap(NormalizedBBox* other) { + if (other == this) return; + InternalSwap(other); +} +void NormalizedBBox::InternalSwap(NormalizedBBox* other) { + std::swap(xmin_, other->xmin_); + std::swap(ymin_, other->ymin_); + std::swap(xmax_, other->xmax_); + std::swap(ymax_, other->ymax_); + std::swap(label_, other->label_); + std::swap(difficult_, other->difficult_); + std::swap(score_, other->score_); + std::swap(size_, other->size_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NormalizedBBox::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NormalizedBBox_descriptor_; + metadata.reflection = NormalizedBBox_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NormalizedBBox + +// optional float xmin = 1; +bool NormalizedBBox::has_xmin() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +void NormalizedBBox::set_has_xmin() { + _has_bits_[0] |= 0x00000001u; +} +void NormalizedBBox::clear_has_xmin() { + _has_bits_[0] &= ~0x00000001u; +} +void NormalizedBBox::clear_xmin() { + xmin_ = 0; + clear_has_xmin(); +} +float NormalizedBBox::xmin() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.xmin) + return xmin_; +} +void NormalizedBBox::set_xmin(float value) { + set_has_xmin(); + xmin_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.xmin) +} + +// optional float ymin = 2; +bool NormalizedBBox::has_ymin() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +void NormalizedBBox::set_has_ymin() { + _has_bits_[0] |= 0x00000002u; +} +void NormalizedBBox::clear_has_ymin() { + _has_bits_[0] &= ~0x00000002u; +} +void NormalizedBBox::clear_ymin() { + ymin_ = 0; + clear_has_ymin(); +} +float NormalizedBBox::ymin() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.ymin) + return ymin_; +} +void NormalizedBBox::set_ymin(float value) { + set_has_ymin(); + ymin_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.ymin) +} + +// optional float xmax = 3; +bool NormalizedBBox::has_xmax() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +void NormalizedBBox::set_has_xmax() { + _has_bits_[0] |= 0x00000004u; +} +void NormalizedBBox::clear_has_xmax() { + _has_bits_[0] &= ~0x00000004u; +} +void NormalizedBBox::clear_xmax() { + xmax_ = 0; + clear_has_xmax(); +} +float NormalizedBBox::xmax() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.xmax) + return xmax_; +} +void NormalizedBBox::set_xmax(float value) { + set_has_xmax(); + xmax_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.xmax) +} + +// optional float ymax = 4; +bool NormalizedBBox::has_ymax() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +void NormalizedBBox::set_has_ymax() { + _has_bits_[0] |= 0x00000008u; +} +void NormalizedBBox::clear_has_ymax() { + _has_bits_[0] &= ~0x00000008u; +} +void NormalizedBBox::clear_ymax() { + ymax_ = 0; + clear_has_ymax(); +} +float NormalizedBBox::ymax() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.ymax) + return ymax_; +} +void NormalizedBBox::set_ymax(float value) { + set_has_ymax(); + ymax_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.ymax) +} + +// optional int32 label = 5; +bool NormalizedBBox::has_label() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +void NormalizedBBox::set_has_label() { + _has_bits_[0] |= 0x00000010u; +} +void NormalizedBBox::clear_has_label() { + _has_bits_[0] &= ~0x00000010u; +} +void NormalizedBBox::clear_label() { + label_ = 0; + clear_has_label(); +} +::google::protobuf::int32 NormalizedBBox::label() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.label) + return label_; +} +void NormalizedBBox::set_label(::google::protobuf::int32 value) { + set_has_label(); + label_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.label) +} + +// optional bool difficult = 6; +bool NormalizedBBox::has_difficult() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +void NormalizedBBox::set_has_difficult() { + _has_bits_[0] |= 0x00000020u; +} +void NormalizedBBox::clear_has_difficult() { + _has_bits_[0] &= ~0x00000020u; +} +void NormalizedBBox::clear_difficult() { + difficult_ = false; + clear_has_difficult(); +} +bool NormalizedBBox::difficult() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.difficult) + return difficult_; +} +void NormalizedBBox::set_difficult(bool value) { + set_has_difficult(); + difficult_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.difficult) +} + +// optional float score = 7; +bool NormalizedBBox::has_score() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +void NormalizedBBox::set_has_score() { + _has_bits_[0] |= 0x00000040u; +} +void NormalizedBBox::clear_has_score() { + _has_bits_[0] &= ~0x00000040u; +} +void NormalizedBBox::clear_score() { + score_ = 0; + clear_has_score(); +} +float NormalizedBBox::score() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.score) + return score_; +} +void NormalizedBBox::set_score(float value) { + set_has_score(); + score_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.score) +} + +// optional float size = 8; +bool NormalizedBBox::has_size() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +void NormalizedBBox::set_has_size() { + _has_bits_[0] |= 0x00000080u; +} +void NormalizedBBox::clear_has_size() { + _has_bits_[0] &= ~0x00000080u; +} +void NormalizedBBox::clear_size() { + size_ = 0; + clear_has_size(); +} +float NormalizedBBox::size() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.size) + return size_; +} +void NormalizedBBox::set_size(float value) { + set_has_size(); + size_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.size) +} + +inline const NormalizedBBox* NormalizedBBox::internal_default_instance() { + return &NormalizedBBox_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace caffe + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/caffe/caffe.pb.h b/modules/dnn/misc/caffe/caffe.pb.h new file mode 100644 index 0000000000..e2fe0832c1 --- /dev/null +++ b/modules/dnn/misc/caffe/caffe.pb.h @@ -0,0 +1,28612 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: caffe.proto + +#ifndef PROTOBUF_caffe_2eproto__INCLUDED +#define PROTOBUF_caffe_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace caffe { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_caffe_2eproto(); +void protobuf_InitDefaults_caffe_2eproto(); +void protobuf_AssignDesc_caffe_2eproto(); +void protobuf_ShutdownFile_caffe_2eproto(); + +class AccuracyParameter; +class ArgMaxParameter; +class BatchNormParameter; +class BiasParameter; +class BlobProto; +class BlobProtoVector; +class BlobShape; +class ConcatParameter; +class ContrastiveLossParameter; +class ConvolutionParameter; +class CropParameter; +class DataParameter; +class Datum; +class DetectionOutputParameter; +class DropoutParameter; +class DummyDataParameter; +class ELUParameter; +class EltwiseParameter; +class EmbedParameter; +class ExpParameter; +class FillerParameter; +class FlattenParameter; +class HDF5DataParameter; +class HDF5OutputParameter; +class HingeLossParameter; +class ImageDataParameter; +class InfogainLossParameter; +class InnerProductParameter; +class InputParameter; +class LRNParameter; +class LayerParameter; +class LogParameter; +class LossParameter; +class MVNParameter; +class MemoryDataParameter; +class NetParameter; +class NetState; +class NetStateRule; +class NonMaximumSuppressionParameter; +class NormalizeBBoxParameter; +class NormalizedBBox; +class PReLUParameter; +class ParamSpec; +class ParameterParameter; +class PermuteParameter; +class PoolingParameter; +class PowerParameter; +class PriorBoxParameter; +class PythonParameter; +class ReLUParameter; +class RecurrentParameter; +class ReductionParameter; +class ReshapeParameter; +class SPPParameter; +class SaveOutputParameter; +class ScaleParameter; +class SigmoidParameter; +class SliceParameter; +class SoftmaxParameter; +class SolverParameter; +class SolverState; +class TanHParameter; +class ThresholdParameter; +class TileParameter; +class TransformationParameter; +class V0LayerParameter; +class V1LayerParameter; +class WindowDataParameter; + +enum PriorBoxParameter_CodeType { + PriorBoxParameter_CodeType_CORNER = 1, + PriorBoxParameter_CodeType_CENTER_SIZE = 2 +}; +bool PriorBoxParameter_CodeType_IsValid(int value); +const PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MIN = PriorBoxParameter_CodeType_CORNER; +const PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MAX = PriorBoxParameter_CodeType_CENTER_SIZE; +const int PriorBoxParameter_CodeType_CodeType_ARRAYSIZE = PriorBoxParameter_CodeType_CodeType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* PriorBoxParameter_CodeType_descriptor(); +inline const ::std::string& PriorBoxParameter_CodeType_Name(PriorBoxParameter_CodeType value) { + return ::google::protobuf::internal::NameOfEnum( + PriorBoxParameter_CodeType_descriptor(), value); +} +inline bool PriorBoxParameter_CodeType_Parse( + const ::std::string& name, PriorBoxParameter_CodeType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + PriorBoxParameter_CodeType_descriptor(), name, value); +} +enum FillerParameter_VarianceNorm { + FillerParameter_VarianceNorm_FAN_IN = 0, + FillerParameter_VarianceNorm_FAN_OUT = 1, + FillerParameter_VarianceNorm_AVERAGE = 2 +}; +bool FillerParameter_VarianceNorm_IsValid(int value); +const FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MIN = FillerParameter_VarianceNorm_FAN_IN; +const FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MAX = FillerParameter_VarianceNorm_AVERAGE; +const int FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE = FillerParameter_VarianceNorm_VarianceNorm_MAX + 1; + +const ::google::protobuf::EnumDescriptor* FillerParameter_VarianceNorm_descriptor(); +inline const ::std::string& FillerParameter_VarianceNorm_Name(FillerParameter_VarianceNorm value) { + return ::google::protobuf::internal::NameOfEnum( + FillerParameter_VarianceNorm_descriptor(), value); +} +inline bool FillerParameter_VarianceNorm_Parse( + const ::std::string& name, FillerParameter_VarianceNorm* value) { + return ::google::protobuf::internal::ParseNamedEnum( + FillerParameter_VarianceNorm_descriptor(), name, value); +} +enum SolverParameter_SnapshotFormat { + SolverParameter_SnapshotFormat_HDF5 = 0, + SolverParameter_SnapshotFormat_BINARYPROTO = 1 +}; +bool SolverParameter_SnapshotFormat_IsValid(int value); +const SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MIN = SolverParameter_SnapshotFormat_HDF5; +const SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MAX = SolverParameter_SnapshotFormat_BINARYPROTO; +const int SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE = SolverParameter_SnapshotFormat_SnapshotFormat_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor(); +inline const ::std::string& SolverParameter_SnapshotFormat_Name(SolverParameter_SnapshotFormat value) { + return ::google::protobuf::internal::NameOfEnum( + SolverParameter_SnapshotFormat_descriptor(), value); +} +inline bool SolverParameter_SnapshotFormat_Parse( + const ::std::string& name, SolverParameter_SnapshotFormat* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SolverParameter_SnapshotFormat_descriptor(), name, value); +} +enum SolverParameter_SolverMode { + SolverParameter_SolverMode_CPU = 0, + SolverParameter_SolverMode_GPU = 1 +}; +bool SolverParameter_SolverMode_IsValid(int value); +const SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MIN = SolverParameter_SolverMode_CPU; +const SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MAX = SolverParameter_SolverMode_GPU; +const int SolverParameter_SolverMode_SolverMode_ARRAYSIZE = SolverParameter_SolverMode_SolverMode_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SolverParameter_SolverMode_descriptor(); +inline const ::std::string& SolverParameter_SolverMode_Name(SolverParameter_SolverMode value) { + return ::google::protobuf::internal::NameOfEnum( + SolverParameter_SolverMode_descriptor(), value); +} +inline bool SolverParameter_SolverMode_Parse( + const ::std::string& name, SolverParameter_SolverMode* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SolverParameter_SolverMode_descriptor(), name, value); +} +enum SolverParameter_SolverType { + SolverParameter_SolverType_SGD = 0, + SolverParameter_SolverType_NESTEROV = 1, + SolverParameter_SolverType_ADAGRAD = 2, + SolverParameter_SolverType_RMSPROP = 3, + SolverParameter_SolverType_ADADELTA = 4, + SolverParameter_SolverType_ADAM = 5 +}; +bool SolverParameter_SolverType_IsValid(int value); +const SolverParameter_SolverType SolverParameter_SolverType_SolverType_MIN = SolverParameter_SolverType_SGD; +const SolverParameter_SolverType SolverParameter_SolverType_SolverType_MAX = SolverParameter_SolverType_ADAM; +const int SolverParameter_SolverType_SolverType_ARRAYSIZE = SolverParameter_SolverType_SolverType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SolverParameter_SolverType_descriptor(); +inline const ::std::string& SolverParameter_SolverType_Name(SolverParameter_SolverType value) { + return ::google::protobuf::internal::NameOfEnum( + SolverParameter_SolverType_descriptor(), value); +} +inline bool SolverParameter_SolverType_Parse( + const ::std::string& name, SolverParameter_SolverType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SolverParameter_SolverType_descriptor(), name, value); +} +enum ParamSpec_DimCheckMode { + ParamSpec_DimCheckMode_STRICT = 0, + ParamSpec_DimCheckMode_PERMISSIVE = 1 +}; +bool ParamSpec_DimCheckMode_IsValid(int value); +const ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MIN = ParamSpec_DimCheckMode_STRICT; +const ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MAX = ParamSpec_DimCheckMode_PERMISSIVE; +const int ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE = ParamSpec_DimCheckMode_DimCheckMode_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ParamSpec_DimCheckMode_descriptor(); +inline const ::std::string& ParamSpec_DimCheckMode_Name(ParamSpec_DimCheckMode value) { + return ::google::protobuf::internal::NameOfEnum( + ParamSpec_DimCheckMode_descriptor(), value); +} +inline bool ParamSpec_DimCheckMode_Parse( + const ::std::string& name, ParamSpec_DimCheckMode* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ParamSpec_DimCheckMode_descriptor(), name, value); +} +enum LossParameter_NormalizationMode { + LossParameter_NormalizationMode_FULL = 0, + LossParameter_NormalizationMode_VALID = 1, + LossParameter_NormalizationMode_BATCH_SIZE = 2, + LossParameter_NormalizationMode_NONE = 3 +}; +bool LossParameter_NormalizationMode_IsValid(int value); +const LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MIN = LossParameter_NormalizationMode_FULL; +const LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MAX = LossParameter_NormalizationMode_NONE; +const int LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE = LossParameter_NormalizationMode_NormalizationMode_MAX + 1; + +const ::google::protobuf::EnumDescriptor* LossParameter_NormalizationMode_descriptor(); +inline const ::std::string& LossParameter_NormalizationMode_Name(LossParameter_NormalizationMode value) { + return ::google::protobuf::internal::NameOfEnum( + LossParameter_NormalizationMode_descriptor(), value); +} +inline bool LossParameter_NormalizationMode_Parse( + const ::std::string& name, LossParameter_NormalizationMode* value) { + return ::google::protobuf::internal::ParseNamedEnum( + LossParameter_NormalizationMode_descriptor(), name, value); +} +enum ConvolutionParameter_Engine { + ConvolutionParameter_Engine_DEFAULT = 0, + ConvolutionParameter_Engine_CAFFE = 1, + ConvolutionParameter_Engine_CUDNN = 2 +}; +bool ConvolutionParameter_Engine_IsValid(int value); +const ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MIN = ConvolutionParameter_Engine_DEFAULT; +const ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MAX = ConvolutionParameter_Engine_CUDNN; +const int ConvolutionParameter_Engine_Engine_ARRAYSIZE = ConvolutionParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ConvolutionParameter_Engine_descriptor(); +inline const ::std::string& ConvolutionParameter_Engine_Name(ConvolutionParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + ConvolutionParameter_Engine_descriptor(), value); +} +inline bool ConvolutionParameter_Engine_Parse( + const ::std::string& name, ConvolutionParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ConvolutionParameter_Engine_descriptor(), name, value); +} +enum DataParameter_DB { + DataParameter_DB_LEVELDB = 0, + DataParameter_DB_LMDB = 1 +}; +bool DataParameter_DB_IsValid(int value); +const DataParameter_DB DataParameter_DB_DB_MIN = DataParameter_DB_LEVELDB; +const DataParameter_DB DataParameter_DB_DB_MAX = DataParameter_DB_LMDB; +const int DataParameter_DB_DB_ARRAYSIZE = DataParameter_DB_DB_MAX + 1; + +const ::google::protobuf::EnumDescriptor* DataParameter_DB_descriptor(); +inline const ::std::string& DataParameter_DB_Name(DataParameter_DB value) { + return ::google::protobuf::internal::NameOfEnum( + DataParameter_DB_descriptor(), value); +} +inline bool DataParameter_DB_Parse( + const ::std::string& name, DataParameter_DB* value) { + return ::google::protobuf::internal::ParseNamedEnum( + DataParameter_DB_descriptor(), name, value); +} +enum EltwiseParameter_EltwiseOp { + EltwiseParameter_EltwiseOp_PROD = 0, + EltwiseParameter_EltwiseOp_SUM = 1, + EltwiseParameter_EltwiseOp_MAX = 2 +}; +bool EltwiseParameter_EltwiseOp_IsValid(int value); +const EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MIN = EltwiseParameter_EltwiseOp_PROD; +const EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MAX = EltwiseParameter_EltwiseOp_MAX; +const int EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE = EltwiseParameter_EltwiseOp_EltwiseOp_MAX + 1; + +const ::google::protobuf::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor(); +inline const ::std::string& EltwiseParameter_EltwiseOp_Name(EltwiseParameter_EltwiseOp value) { + return ::google::protobuf::internal::NameOfEnum( + EltwiseParameter_EltwiseOp_descriptor(), value); +} +inline bool EltwiseParameter_EltwiseOp_Parse( + const ::std::string& name, EltwiseParameter_EltwiseOp* value) { + return ::google::protobuf::internal::ParseNamedEnum( + EltwiseParameter_EltwiseOp_descriptor(), name, value); +} +enum HingeLossParameter_Norm { + HingeLossParameter_Norm_L1 = 1, + HingeLossParameter_Norm_L2 = 2 +}; +bool HingeLossParameter_Norm_IsValid(int value); +const HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MIN = HingeLossParameter_Norm_L1; +const HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MAX = HingeLossParameter_Norm_L2; +const int HingeLossParameter_Norm_Norm_ARRAYSIZE = HingeLossParameter_Norm_Norm_MAX + 1; + +const ::google::protobuf::EnumDescriptor* HingeLossParameter_Norm_descriptor(); +inline const ::std::string& HingeLossParameter_Norm_Name(HingeLossParameter_Norm value) { + return ::google::protobuf::internal::NameOfEnum( + HingeLossParameter_Norm_descriptor(), value); +} +inline bool HingeLossParameter_Norm_Parse( + const ::std::string& name, HingeLossParameter_Norm* value) { + return ::google::protobuf::internal::ParseNamedEnum( + HingeLossParameter_Norm_descriptor(), name, value); +} +enum LRNParameter_NormRegion { + LRNParameter_NormRegion_ACROSS_CHANNELS = 0, + LRNParameter_NormRegion_WITHIN_CHANNEL = 1 +}; +bool LRNParameter_NormRegion_IsValid(int value); +const LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MIN = LRNParameter_NormRegion_ACROSS_CHANNELS; +const LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MAX = LRNParameter_NormRegion_WITHIN_CHANNEL; +const int LRNParameter_NormRegion_NormRegion_ARRAYSIZE = LRNParameter_NormRegion_NormRegion_MAX + 1; + +const ::google::protobuf::EnumDescriptor* LRNParameter_NormRegion_descriptor(); +inline const ::std::string& LRNParameter_NormRegion_Name(LRNParameter_NormRegion value) { + return ::google::protobuf::internal::NameOfEnum( + LRNParameter_NormRegion_descriptor(), value); +} +inline bool LRNParameter_NormRegion_Parse( + const ::std::string& name, LRNParameter_NormRegion* value) { + return ::google::protobuf::internal::ParseNamedEnum( + LRNParameter_NormRegion_descriptor(), name, value); +} +enum LRNParameter_Engine { + LRNParameter_Engine_DEFAULT = 0, + LRNParameter_Engine_CAFFE = 1, + LRNParameter_Engine_CUDNN = 2 +}; +bool LRNParameter_Engine_IsValid(int value); +const LRNParameter_Engine LRNParameter_Engine_Engine_MIN = LRNParameter_Engine_DEFAULT; +const LRNParameter_Engine LRNParameter_Engine_Engine_MAX = LRNParameter_Engine_CUDNN; +const int LRNParameter_Engine_Engine_ARRAYSIZE = LRNParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* LRNParameter_Engine_descriptor(); +inline const ::std::string& LRNParameter_Engine_Name(LRNParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + LRNParameter_Engine_descriptor(), value); +} +inline bool LRNParameter_Engine_Parse( + const ::std::string& name, LRNParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + LRNParameter_Engine_descriptor(), name, value); +} +enum PoolingParameter_PoolMethod { + PoolingParameter_PoolMethod_MAX = 0, + PoolingParameter_PoolMethod_AVE = 1, + PoolingParameter_PoolMethod_STOCHASTIC = 2 +}; +bool PoolingParameter_PoolMethod_IsValid(int value); +const PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MIN = PoolingParameter_PoolMethod_MAX; +const PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MAX = PoolingParameter_PoolMethod_STOCHASTIC; +const int PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE = PoolingParameter_PoolMethod_PoolMethod_MAX + 1; + +const ::google::protobuf::EnumDescriptor* PoolingParameter_PoolMethod_descriptor(); +inline const ::std::string& PoolingParameter_PoolMethod_Name(PoolingParameter_PoolMethod value) { + return ::google::protobuf::internal::NameOfEnum( + PoolingParameter_PoolMethod_descriptor(), value); +} +inline bool PoolingParameter_PoolMethod_Parse( + const ::std::string& name, PoolingParameter_PoolMethod* value) { + return ::google::protobuf::internal::ParseNamedEnum( + PoolingParameter_PoolMethod_descriptor(), name, value); +} +enum PoolingParameter_Engine { + PoolingParameter_Engine_DEFAULT = 0, + PoolingParameter_Engine_CAFFE = 1, + PoolingParameter_Engine_CUDNN = 2 +}; +bool PoolingParameter_Engine_IsValid(int value); +const PoolingParameter_Engine PoolingParameter_Engine_Engine_MIN = PoolingParameter_Engine_DEFAULT; +const PoolingParameter_Engine PoolingParameter_Engine_Engine_MAX = PoolingParameter_Engine_CUDNN; +const int PoolingParameter_Engine_Engine_ARRAYSIZE = PoolingParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* PoolingParameter_Engine_descriptor(); +inline const ::std::string& PoolingParameter_Engine_Name(PoolingParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + PoolingParameter_Engine_descriptor(), value); +} +inline bool PoolingParameter_Engine_Parse( + const ::std::string& name, PoolingParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + PoolingParameter_Engine_descriptor(), name, value); +} +enum ReductionParameter_ReductionOp { + ReductionParameter_ReductionOp_SUM = 1, + ReductionParameter_ReductionOp_ASUM = 2, + ReductionParameter_ReductionOp_SUMSQ = 3, + ReductionParameter_ReductionOp_MEAN = 4 +}; +bool ReductionParameter_ReductionOp_IsValid(int value); +const ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MIN = ReductionParameter_ReductionOp_SUM; +const ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MAX = ReductionParameter_ReductionOp_MEAN; +const int ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE = ReductionParameter_ReductionOp_ReductionOp_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ReductionParameter_ReductionOp_descriptor(); +inline const ::std::string& ReductionParameter_ReductionOp_Name(ReductionParameter_ReductionOp value) { + return ::google::protobuf::internal::NameOfEnum( + ReductionParameter_ReductionOp_descriptor(), value); +} +inline bool ReductionParameter_ReductionOp_Parse( + const ::std::string& name, ReductionParameter_ReductionOp* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ReductionParameter_ReductionOp_descriptor(), name, value); +} +enum ReLUParameter_Engine { + ReLUParameter_Engine_DEFAULT = 0, + ReLUParameter_Engine_CAFFE = 1, + ReLUParameter_Engine_CUDNN = 2 +}; +bool ReLUParameter_Engine_IsValid(int value); +const ReLUParameter_Engine ReLUParameter_Engine_Engine_MIN = ReLUParameter_Engine_DEFAULT; +const ReLUParameter_Engine ReLUParameter_Engine_Engine_MAX = ReLUParameter_Engine_CUDNN; +const int ReLUParameter_Engine_Engine_ARRAYSIZE = ReLUParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ReLUParameter_Engine_descriptor(); +inline const ::std::string& ReLUParameter_Engine_Name(ReLUParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + ReLUParameter_Engine_descriptor(), value); +} +inline bool ReLUParameter_Engine_Parse( + const ::std::string& name, ReLUParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ReLUParameter_Engine_descriptor(), name, value); +} +enum SigmoidParameter_Engine { + SigmoidParameter_Engine_DEFAULT = 0, + SigmoidParameter_Engine_CAFFE = 1, + SigmoidParameter_Engine_CUDNN = 2 +}; +bool SigmoidParameter_Engine_IsValid(int value); +const SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MIN = SigmoidParameter_Engine_DEFAULT; +const SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MAX = SigmoidParameter_Engine_CUDNN; +const int SigmoidParameter_Engine_Engine_ARRAYSIZE = SigmoidParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SigmoidParameter_Engine_descriptor(); +inline const ::std::string& SigmoidParameter_Engine_Name(SigmoidParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + SigmoidParameter_Engine_descriptor(), value); +} +inline bool SigmoidParameter_Engine_Parse( + const ::std::string& name, SigmoidParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SigmoidParameter_Engine_descriptor(), name, value); +} +enum SoftmaxParameter_Engine { + SoftmaxParameter_Engine_DEFAULT = 0, + SoftmaxParameter_Engine_CAFFE = 1, + SoftmaxParameter_Engine_CUDNN = 2 +}; +bool SoftmaxParameter_Engine_IsValid(int value); +const SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MIN = SoftmaxParameter_Engine_DEFAULT; +const SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MAX = SoftmaxParameter_Engine_CUDNN; +const int SoftmaxParameter_Engine_Engine_ARRAYSIZE = SoftmaxParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SoftmaxParameter_Engine_descriptor(); +inline const ::std::string& SoftmaxParameter_Engine_Name(SoftmaxParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + SoftmaxParameter_Engine_descriptor(), value); +} +inline bool SoftmaxParameter_Engine_Parse( + const ::std::string& name, SoftmaxParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SoftmaxParameter_Engine_descriptor(), name, value); +} +enum TanHParameter_Engine { + TanHParameter_Engine_DEFAULT = 0, + TanHParameter_Engine_CAFFE = 1, + TanHParameter_Engine_CUDNN = 2 +}; +bool TanHParameter_Engine_IsValid(int value); +const TanHParameter_Engine TanHParameter_Engine_Engine_MIN = TanHParameter_Engine_DEFAULT; +const TanHParameter_Engine TanHParameter_Engine_Engine_MAX = TanHParameter_Engine_CUDNN; +const int TanHParameter_Engine_Engine_ARRAYSIZE = TanHParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* TanHParameter_Engine_descriptor(); +inline const ::std::string& TanHParameter_Engine_Name(TanHParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + TanHParameter_Engine_descriptor(), value); +} +inline bool TanHParameter_Engine_Parse( + const ::std::string& name, TanHParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + TanHParameter_Engine_descriptor(), name, value); +} +enum SPPParameter_PoolMethod { + SPPParameter_PoolMethod_MAX = 0, + SPPParameter_PoolMethod_AVE = 1, + SPPParameter_PoolMethod_STOCHASTIC = 2 +}; +bool SPPParameter_PoolMethod_IsValid(int value); +const SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MIN = SPPParameter_PoolMethod_MAX; +const SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MAX = SPPParameter_PoolMethod_STOCHASTIC; +const int SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE = SPPParameter_PoolMethod_PoolMethod_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SPPParameter_PoolMethod_descriptor(); +inline const ::std::string& SPPParameter_PoolMethod_Name(SPPParameter_PoolMethod value) { + return ::google::protobuf::internal::NameOfEnum( + SPPParameter_PoolMethod_descriptor(), value); +} +inline bool SPPParameter_PoolMethod_Parse( + const ::std::string& name, SPPParameter_PoolMethod* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SPPParameter_PoolMethod_descriptor(), name, value); +} +enum SPPParameter_Engine { + SPPParameter_Engine_DEFAULT = 0, + SPPParameter_Engine_CAFFE = 1, + SPPParameter_Engine_CUDNN = 2 +}; +bool SPPParameter_Engine_IsValid(int value); +const SPPParameter_Engine SPPParameter_Engine_Engine_MIN = SPPParameter_Engine_DEFAULT; +const SPPParameter_Engine SPPParameter_Engine_Engine_MAX = SPPParameter_Engine_CUDNN; +const int SPPParameter_Engine_Engine_ARRAYSIZE = SPPParameter_Engine_Engine_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SPPParameter_Engine_descriptor(); +inline const ::std::string& SPPParameter_Engine_Name(SPPParameter_Engine value) { + return ::google::protobuf::internal::NameOfEnum( + SPPParameter_Engine_descriptor(), value); +} +inline bool SPPParameter_Engine_Parse( + const ::std::string& name, SPPParameter_Engine* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SPPParameter_Engine_descriptor(), name, value); +} +enum V1LayerParameter_LayerType { + V1LayerParameter_LayerType_NONE = 0, + V1LayerParameter_LayerType_ABSVAL = 35, + V1LayerParameter_LayerType_ACCURACY = 1, + V1LayerParameter_LayerType_ARGMAX = 30, + V1LayerParameter_LayerType_BNLL = 2, + V1LayerParameter_LayerType_CONCAT = 3, + V1LayerParameter_LayerType_CONTRASTIVE_LOSS = 37, + V1LayerParameter_LayerType_CONVOLUTION = 4, + V1LayerParameter_LayerType_DATA = 5, + V1LayerParameter_LayerType_DECONVOLUTION = 39, + V1LayerParameter_LayerType_DROPOUT = 6, + V1LayerParameter_LayerType_DUMMY_DATA = 32, + V1LayerParameter_LayerType_EUCLIDEAN_LOSS = 7, + V1LayerParameter_LayerType_ELTWISE = 25, + V1LayerParameter_LayerType_EXP = 38, + V1LayerParameter_LayerType_FLATTEN = 8, + V1LayerParameter_LayerType_HDF5_DATA = 9, + V1LayerParameter_LayerType_HDF5_OUTPUT = 10, + V1LayerParameter_LayerType_HINGE_LOSS = 28, + V1LayerParameter_LayerType_IM2COL = 11, + V1LayerParameter_LayerType_IMAGE_DATA = 12, + V1LayerParameter_LayerType_INFOGAIN_LOSS = 13, + V1LayerParameter_LayerType_INNER_PRODUCT = 14, + V1LayerParameter_LayerType_LRN = 15, + V1LayerParameter_LayerType_MEMORY_DATA = 29, + V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS = 16, + V1LayerParameter_LayerType_MVN = 34, + V1LayerParameter_LayerType_POOLING = 17, + V1LayerParameter_LayerType_POWER = 26, + V1LayerParameter_LayerType_RELU = 18, + V1LayerParameter_LayerType_SIGMOID = 19, + V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS = 27, + V1LayerParameter_LayerType_SILENCE = 36, + V1LayerParameter_LayerType_SOFTMAX = 20, + V1LayerParameter_LayerType_SOFTMAX_LOSS = 21, + V1LayerParameter_LayerType_SPLIT = 22, + V1LayerParameter_LayerType_SLICE = 33, + V1LayerParameter_LayerType_TANH = 23, + V1LayerParameter_LayerType_WINDOW_DATA = 24, + V1LayerParameter_LayerType_THRESHOLD = 31 +}; +bool V1LayerParameter_LayerType_IsValid(int value); +const V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MIN = V1LayerParameter_LayerType_NONE; +const V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MAX = V1LayerParameter_LayerType_DECONVOLUTION; +const int V1LayerParameter_LayerType_LayerType_ARRAYSIZE = V1LayerParameter_LayerType_LayerType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* V1LayerParameter_LayerType_descriptor(); +inline const ::std::string& V1LayerParameter_LayerType_Name(V1LayerParameter_LayerType value) { + return ::google::protobuf::internal::NameOfEnum( + V1LayerParameter_LayerType_descriptor(), value); +} +inline bool V1LayerParameter_LayerType_Parse( + const ::std::string& name, V1LayerParameter_LayerType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + V1LayerParameter_LayerType_descriptor(), name, value); +} +enum V1LayerParameter_DimCheckMode { + V1LayerParameter_DimCheckMode_STRICT = 0, + V1LayerParameter_DimCheckMode_PERMISSIVE = 1 +}; +bool V1LayerParameter_DimCheckMode_IsValid(int value); +const V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MIN = V1LayerParameter_DimCheckMode_STRICT; +const V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MAX = V1LayerParameter_DimCheckMode_PERMISSIVE; +const int V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE = V1LayerParameter_DimCheckMode_DimCheckMode_MAX + 1; + +const ::google::protobuf::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor(); +inline const ::std::string& V1LayerParameter_DimCheckMode_Name(V1LayerParameter_DimCheckMode value) { + return ::google::protobuf::internal::NameOfEnum( + V1LayerParameter_DimCheckMode_descriptor(), value); +} +inline bool V1LayerParameter_DimCheckMode_Parse( + const ::std::string& name, V1LayerParameter_DimCheckMode* value) { + return ::google::protobuf::internal::ParseNamedEnum( + V1LayerParameter_DimCheckMode_descriptor(), name, value); +} +enum V0LayerParameter_PoolMethod { + V0LayerParameter_PoolMethod_MAX = 0, + V0LayerParameter_PoolMethod_AVE = 1, + V0LayerParameter_PoolMethod_STOCHASTIC = 2 +}; +bool V0LayerParameter_PoolMethod_IsValid(int value); +const V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MIN = V0LayerParameter_PoolMethod_MAX; +const V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MAX = V0LayerParameter_PoolMethod_STOCHASTIC; +const int V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE = V0LayerParameter_PoolMethod_PoolMethod_MAX + 1; + +const ::google::protobuf::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor(); +inline const ::std::string& V0LayerParameter_PoolMethod_Name(V0LayerParameter_PoolMethod value) { + return ::google::protobuf::internal::NameOfEnum( + V0LayerParameter_PoolMethod_descriptor(), value); +} +inline bool V0LayerParameter_PoolMethod_Parse( + const ::std::string& name, V0LayerParameter_PoolMethod* value) { + return ::google::protobuf::internal::ParseNamedEnum( + V0LayerParameter_PoolMethod_descriptor(), name, value); +} +enum Phase { + TRAIN = 0, + TEST = 1 +}; +bool Phase_IsValid(int value); +const Phase Phase_MIN = TRAIN; +const Phase Phase_MAX = TEST; +const int Phase_ARRAYSIZE = Phase_MAX + 1; + +const ::google::protobuf::EnumDescriptor* Phase_descriptor(); +inline const ::std::string& Phase_Name(Phase value) { + return ::google::protobuf::internal::NameOfEnum( + Phase_descriptor(), value); +} +inline bool Phase_Parse( + const ::std::string& name, Phase* value) { + return ::google::protobuf::internal::ParseNamedEnum( + Phase_descriptor(), name, value); +} +// =================================================================== + +class BlobShape : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.BlobShape) */ { + public: + BlobShape(); + virtual ~BlobShape(); + + BlobShape(const BlobShape& from); + + inline BlobShape& operator=(const BlobShape& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BlobShape& default_instance(); + + static const BlobShape* internal_default_instance(); + + void Swap(BlobShape* other); + + // implements Message ---------------------------------------------- + + inline BlobShape* New() const { return New(NULL); } + + BlobShape* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BlobShape& from); + void MergeFrom(const BlobShape& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BlobShape* other); + void UnsafeMergeFrom(const BlobShape& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated int64 dim = 1 [packed = true]; + int dim_size() const; + void clear_dim(); + static const int kDimFieldNumber = 1; + ::google::protobuf::int64 dim(int index) const; + void set_dim(int index, ::google::protobuf::int64 value); + void add_dim(::google::protobuf::int64 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& + dim() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int64 >* + mutable_dim(); + + // @@protoc_insertion_point(class_scope:caffe.BlobShape) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::int64 > dim_; + mutable int _dim_cached_byte_size_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed BlobShape_default_instance_; + +// ------------------------------------------------------------------- + +class BlobProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.BlobProto) */ { + public: + BlobProto(); + virtual ~BlobProto(); + + BlobProto(const BlobProto& from); + + inline BlobProto& operator=(const BlobProto& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BlobProto& default_instance(); + + static const BlobProto* internal_default_instance(); + + void Swap(BlobProto* other); + + // implements Message ---------------------------------------------- + + inline BlobProto* New() const { return New(NULL); } + + BlobProto* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BlobProto& from); + void MergeFrom(const BlobProto& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BlobProto* other); + void UnsafeMergeFrom(const BlobProto& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .caffe.BlobShape shape = 7; + bool has_shape() const; + void clear_shape(); + static const int kShapeFieldNumber = 7; + const ::caffe::BlobShape& shape() const; + ::caffe::BlobShape* mutable_shape(); + ::caffe::BlobShape* release_shape(); + void set_allocated_shape(::caffe::BlobShape* shape); + + // repeated float data = 5 [packed = true]; + int data_size() const; + void clear_data(); + static const int kDataFieldNumber = 5; + float data(int index) const; + void set_data(int index, float value); + void add_data(float value); + const ::google::protobuf::RepeatedField< float >& + data() const; + ::google::protobuf::RepeatedField< float >* + mutable_data(); + + // repeated float diff = 6 [packed = true]; + int diff_size() const; + void clear_diff(); + static const int kDiffFieldNumber = 6; + float diff(int index) const; + void set_diff(int index, float value); + void add_diff(float value); + const ::google::protobuf::RepeatedField< float >& + diff() const; + ::google::protobuf::RepeatedField< float >* + mutable_diff(); + + // repeated double double_data = 8 [packed = true]; + int double_data_size() const; + void clear_double_data(); + static const int kDoubleDataFieldNumber = 8; + double double_data(int index) const; + void set_double_data(int index, double value); + void add_double_data(double value); + const ::google::protobuf::RepeatedField< double >& + double_data() const; + ::google::protobuf::RepeatedField< double >* + mutable_double_data(); + + // repeated double double_diff = 9 [packed = true]; + int double_diff_size() const; + void clear_double_diff(); + static const int kDoubleDiffFieldNumber = 9; + double double_diff(int index) const; + void set_double_diff(int index, double value); + void add_double_diff(double value); + const ::google::protobuf::RepeatedField< double >& + double_diff() const; + ::google::protobuf::RepeatedField< double >* + mutable_double_diff(); + + // optional int32 num = 1 [default = 0]; + bool has_num() const; + void clear_num(); + static const int kNumFieldNumber = 1; + ::google::protobuf::int32 num() const; + void set_num(::google::protobuf::int32 value); + + // optional int32 channels = 2 [default = 0]; + bool has_channels() const; + void clear_channels(); + static const int kChannelsFieldNumber = 2; + ::google::protobuf::int32 channels() const; + void set_channels(::google::protobuf::int32 value); + + // optional int32 height = 3 [default = 0]; + bool has_height() const; + void clear_height(); + static const int kHeightFieldNumber = 3; + ::google::protobuf::int32 height() const; + void set_height(::google::protobuf::int32 value); + + // optional int32 width = 4 [default = 0]; + bool has_width() const; + void clear_width(); + static const int kWidthFieldNumber = 4; + ::google::protobuf::int32 width() const; + void set_width(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.BlobProto) + private: + inline void set_has_shape(); + inline void clear_has_shape(); + inline void set_has_num(); + inline void clear_has_num(); + inline void set_has_channels(); + inline void clear_has_channels(); + inline void set_has_height(); + inline void clear_has_height(); + inline void set_has_width(); + inline void clear_has_width(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< float > data_; + mutable int _data_cached_byte_size_; + ::google::protobuf::RepeatedField< float > diff_; + mutable int _diff_cached_byte_size_; + ::google::protobuf::RepeatedField< double > double_data_; + mutable int _double_data_cached_byte_size_; + ::google::protobuf::RepeatedField< double > double_diff_; + mutable int _double_diff_cached_byte_size_; + ::caffe::BlobShape* shape_; + ::google::protobuf::int32 num_; + ::google::protobuf::int32 channels_; + ::google::protobuf::int32 height_; + ::google::protobuf::int32 width_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed BlobProto_default_instance_; + +// ------------------------------------------------------------------- + +class BlobProtoVector : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.BlobProtoVector) */ { + public: + BlobProtoVector(); + virtual ~BlobProtoVector(); + + BlobProtoVector(const BlobProtoVector& from); + + inline BlobProtoVector& operator=(const BlobProtoVector& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BlobProtoVector& default_instance(); + + static const BlobProtoVector* internal_default_instance(); + + void Swap(BlobProtoVector* other); + + // implements Message ---------------------------------------------- + + inline BlobProtoVector* New() const { return New(NULL); } + + BlobProtoVector* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BlobProtoVector& from); + void MergeFrom(const BlobProtoVector& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BlobProtoVector* other); + void UnsafeMergeFrom(const BlobProtoVector& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .caffe.BlobProto blobs = 1; + int blobs_size() const; + void clear_blobs(); + static const int kBlobsFieldNumber = 1; + const ::caffe::BlobProto& blobs(int index) const; + ::caffe::BlobProto* mutable_blobs(int index); + ::caffe::BlobProto* add_blobs(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* + mutable_blobs(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& + blobs() const; + + // @@protoc_insertion_point(class_scope:caffe.BlobProtoVector) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > blobs_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed BlobProtoVector_default_instance_; + +// ------------------------------------------------------------------- + +class PermuteParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.PermuteParameter) */ { + public: + PermuteParameter(); + virtual ~PermuteParameter(); + + PermuteParameter(const PermuteParameter& from); + + inline PermuteParameter& operator=(const PermuteParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PermuteParameter& default_instance(); + + static const PermuteParameter* internal_default_instance(); + + void Swap(PermuteParameter* other); + + // implements Message ---------------------------------------------- + + inline PermuteParameter* New() const { return New(NULL); } + + PermuteParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PermuteParameter& from); + void MergeFrom(const PermuteParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PermuteParameter* other); + void UnsafeMergeFrom(const PermuteParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated uint32 order = 1; + int order_size() const; + void clear_order(); + static const int kOrderFieldNumber = 1; + ::google::protobuf::uint32 order(int index) const; + void set_order(int index, ::google::protobuf::uint32 value); + void add_order(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + order() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_order(); + + // @@protoc_insertion_point(class_scope:caffe.PermuteParameter) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > order_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed PermuteParameter_default_instance_; + +// ------------------------------------------------------------------- + +class NormalizeBBoxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.NormalizeBBoxParameter) */ { + public: + NormalizeBBoxParameter(); + virtual ~NormalizeBBoxParameter(); + + NormalizeBBoxParameter(const NormalizeBBoxParameter& from); + + inline NormalizeBBoxParameter& operator=(const NormalizeBBoxParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NormalizeBBoxParameter& default_instance(); + + static const NormalizeBBoxParameter* internal_default_instance(); + + void Swap(NormalizeBBoxParameter* other); + + // implements Message ---------------------------------------------- + + inline NormalizeBBoxParameter* New() const { return New(NULL); } + + NormalizeBBoxParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NormalizeBBoxParameter& from); + void MergeFrom(const NormalizeBBoxParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NormalizeBBoxParameter* other); + void UnsafeMergeFrom(const NormalizeBBoxParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool across_spatial = 1 [default = true]; + bool has_across_spatial() const; + void clear_across_spatial(); + static const int kAcrossSpatialFieldNumber = 1; + bool across_spatial() const; + void set_across_spatial(bool value); + + // optional .caffe.FillerParameter scale_filler = 2; + bool has_scale_filler() const; + void clear_scale_filler(); + static const int kScaleFillerFieldNumber = 2; + const ::caffe::FillerParameter& scale_filler() const; + ::caffe::FillerParameter* mutable_scale_filler(); + ::caffe::FillerParameter* release_scale_filler(); + void set_allocated_scale_filler(::caffe::FillerParameter* scale_filler); + + // optional bool channel_shared = 3 [default = true]; + bool has_channel_shared() const; + void clear_channel_shared(); + static const int kChannelSharedFieldNumber = 3; + bool channel_shared() const; + void set_channel_shared(bool value); + + // optional float eps = 4 [default = 1e-10]; + bool has_eps() const; + void clear_eps(); + static const int kEpsFieldNumber = 4; + float eps() const; + void set_eps(float value); + + // @@protoc_insertion_point(class_scope:caffe.NormalizeBBoxParameter) + private: + inline void set_has_across_spatial(); + inline void clear_has_across_spatial(); + inline void set_has_scale_filler(); + inline void clear_has_scale_filler(); + inline void set_has_channel_shared(); + inline void clear_has_channel_shared(); + inline void set_has_eps(); + inline void clear_has_eps(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::FillerParameter* scale_filler_; + bool across_spatial_; + bool channel_shared_; + float eps_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NormalizeBBoxParameter_default_instance_; + +// ------------------------------------------------------------------- + +class PriorBoxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.PriorBoxParameter) */ { + public: + PriorBoxParameter(); + virtual ~PriorBoxParameter(); + + PriorBoxParameter(const PriorBoxParameter& from); + + inline PriorBoxParameter& operator=(const PriorBoxParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PriorBoxParameter& default_instance(); + + static const PriorBoxParameter* internal_default_instance(); + + void Swap(PriorBoxParameter* other); + + // implements Message ---------------------------------------------- + + inline PriorBoxParameter* New() const { return New(NULL); } + + PriorBoxParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PriorBoxParameter& from); + void MergeFrom(const PriorBoxParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PriorBoxParameter* other); + void UnsafeMergeFrom(const PriorBoxParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef PriorBoxParameter_CodeType CodeType; + static const CodeType CORNER = + PriorBoxParameter_CodeType_CORNER; + static const CodeType CENTER_SIZE = + PriorBoxParameter_CodeType_CENTER_SIZE; + static inline bool CodeType_IsValid(int value) { + return PriorBoxParameter_CodeType_IsValid(value); + } + static const CodeType CodeType_MIN = + PriorBoxParameter_CodeType_CodeType_MIN; + static const CodeType CodeType_MAX = + PriorBoxParameter_CodeType_CodeType_MAX; + static const int CodeType_ARRAYSIZE = + PriorBoxParameter_CodeType_CodeType_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + CodeType_descriptor() { + return PriorBoxParameter_CodeType_descriptor(); + } + static inline const ::std::string& CodeType_Name(CodeType value) { + return PriorBoxParameter_CodeType_Name(value); + } + static inline bool CodeType_Parse(const ::std::string& name, + CodeType* value) { + return PriorBoxParameter_CodeType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional float min_size = 1; + bool has_min_size() const; + void clear_min_size(); + static const int kMinSizeFieldNumber = 1; + float min_size() const; + void set_min_size(float value); + + // optional float max_size = 2; + bool has_max_size() const; + void clear_max_size(); + static const int kMaxSizeFieldNumber = 2; + float max_size() const; + void set_max_size(float value); + + // repeated float aspect_ratio = 3; + int aspect_ratio_size() const; + void clear_aspect_ratio(); + static const int kAspectRatioFieldNumber = 3; + float aspect_ratio(int index) const; + void set_aspect_ratio(int index, float value); + void add_aspect_ratio(float value); + const ::google::protobuf::RepeatedField< float >& + aspect_ratio() const; + ::google::protobuf::RepeatedField< float >* + mutable_aspect_ratio(); + + // optional bool flip = 4 [default = true]; + bool has_flip() const; + void clear_flip(); + static const int kFlipFieldNumber = 4; + bool flip() const; + void set_flip(bool value); + + // optional bool clip = 5 [default = true]; + bool has_clip() const; + void clear_clip(); + static const int kClipFieldNumber = 5; + bool clip() const; + void set_clip(bool value); + + // repeated float variance = 6; + int variance_size() const; + void clear_variance(); + static const int kVarianceFieldNumber = 6; + float variance(int index) const; + void set_variance(int index, float value); + void add_variance(float value); + const ::google::protobuf::RepeatedField< float >& + variance() const; + ::google::protobuf::RepeatedField< float >* + mutable_variance(); + + // optional uint32 img_size = 7; + bool has_img_size() const; + void clear_img_size(); + static const int kImgSizeFieldNumber = 7; + ::google::protobuf::uint32 img_size() const; + void set_img_size(::google::protobuf::uint32 value); + + // optional uint32 img_h = 8; + bool has_img_h() const; + void clear_img_h(); + static const int kImgHFieldNumber = 8; + ::google::protobuf::uint32 img_h() const; + void set_img_h(::google::protobuf::uint32 value); + + // optional uint32 img_w = 9; + bool has_img_w() const; + void clear_img_w(); + static const int kImgWFieldNumber = 9; + ::google::protobuf::uint32 img_w() const; + void set_img_w(::google::protobuf::uint32 value); + + // optional float step = 10; + bool has_step() const; + void clear_step(); + static const int kStepFieldNumber = 10; + float step() const; + void set_step(float value); + + // optional float step_h = 11; + bool has_step_h() const; + void clear_step_h(); + static const int kStepHFieldNumber = 11; + float step_h() const; + void set_step_h(float value); + + // optional float step_w = 12; + bool has_step_w() const; + void clear_step_w(); + static const int kStepWFieldNumber = 12; + float step_w() const; + void set_step_w(float value); + + // optional float offset = 13 [default = 0.5]; + bool has_offset() const; + void clear_offset(); + static const int kOffsetFieldNumber = 13; + float offset() const; + void set_offset(float value); + + // @@protoc_insertion_point(class_scope:caffe.PriorBoxParameter) + private: + inline void set_has_min_size(); + inline void clear_has_min_size(); + inline void set_has_max_size(); + inline void clear_has_max_size(); + inline void set_has_flip(); + inline void clear_has_flip(); + inline void set_has_clip(); + inline void clear_has_clip(); + inline void set_has_img_size(); + inline void clear_has_img_size(); + inline void set_has_img_h(); + inline void clear_has_img_h(); + inline void set_has_img_w(); + inline void clear_has_img_w(); + inline void set_has_step(); + inline void clear_has_step(); + inline void set_has_step_h(); + inline void clear_has_step_h(); + inline void set_has_step_w(); + inline void clear_has_step_w(); + inline void set_has_offset(); + inline void clear_has_offset(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< float > aspect_ratio_; + ::google::protobuf::RepeatedField< float > variance_; + float min_size_; + float max_size_; + ::google::protobuf::uint32 img_size_; + ::google::protobuf::uint32 img_h_; + ::google::protobuf::uint32 img_w_; + float step_; + float step_h_; + float step_w_; + bool flip_; + bool clip_; + float offset_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed PriorBoxParameter_default_instance_; + +// ------------------------------------------------------------------- + +class DetectionOutputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.DetectionOutputParameter) */ { + public: + DetectionOutputParameter(); + virtual ~DetectionOutputParameter(); + + DetectionOutputParameter(const DetectionOutputParameter& from); + + inline DetectionOutputParameter& operator=(const DetectionOutputParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DetectionOutputParameter& default_instance(); + + static const DetectionOutputParameter* internal_default_instance(); + + void Swap(DetectionOutputParameter* other); + + // implements Message ---------------------------------------------- + + inline DetectionOutputParameter* New() const { return New(NULL); } + + DetectionOutputParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DetectionOutputParameter& from); + void MergeFrom(const DetectionOutputParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(DetectionOutputParameter* other); + void UnsafeMergeFrom(const DetectionOutputParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 num_classes = 1; + bool has_num_classes() const; + void clear_num_classes(); + static const int kNumClassesFieldNumber = 1; + ::google::protobuf::uint32 num_classes() const; + void set_num_classes(::google::protobuf::uint32 value); + + // optional bool share_location = 2 [default = true]; + bool has_share_location() const; + void clear_share_location(); + static const int kShareLocationFieldNumber = 2; + bool share_location() const; + void set_share_location(bool value); + + // optional int32 background_label_id = 3 [default = 0]; + bool has_background_label_id() const; + void clear_background_label_id(); + static const int kBackgroundLabelIdFieldNumber = 3; + ::google::protobuf::int32 background_label_id() const; + void set_background_label_id(::google::protobuf::int32 value); + + // optional .caffe.NonMaximumSuppressionParameter nms_param = 4; + bool has_nms_param() const; + void clear_nms_param(); + static const int kNmsParamFieldNumber = 4; + const ::caffe::NonMaximumSuppressionParameter& nms_param() const; + ::caffe::NonMaximumSuppressionParameter* mutable_nms_param(); + ::caffe::NonMaximumSuppressionParameter* release_nms_param(); + void set_allocated_nms_param(::caffe::NonMaximumSuppressionParameter* nms_param); + + // optional .caffe.SaveOutputParameter save_output_param = 5; + bool has_save_output_param() const; + void clear_save_output_param(); + static const int kSaveOutputParamFieldNumber = 5; + const ::caffe::SaveOutputParameter& save_output_param() const; + ::caffe::SaveOutputParameter* mutable_save_output_param(); + ::caffe::SaveOutputParameter* release_save_output_param(); + void set_allocated_save_output_param(::caffe::SaveOutputParameter* save_output_param); + + // optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + bool has_code_type() const; + void clear_code_type(); + static const int kCodeTypeFieldNumber = 6; + ::caffe::PriorBoxParameter_CodeType code_type() const; + void set_code_type(::caffe::PriorBoxParameter_CodeType value); + + // optional bool variance_encoded_in_target = 8 [default = false]; + bool has_variance_encoded_in_target() const; + void clear_variance_encoded_in_target(); + static const int kVarianceEncodedInTargetFieldNumber = 8; + bool variance_encoded_in_target() const; + void set_variance_encoded_in_target(bool value); + + // optional int32 keep_top_k = 7 [default = -1]; + bool has_keep_top_k() const; + void clear_keep_top_k(); + static const int kKeepTopKFieldNumber = 7; + ::google::protobuf::int32 keep_top_k() const; + void set_keep_top_k(::google::protobuf::int32 value); + + // optional float confidence_threshold = 9; + bool has_confidence_threshold() const; + void clear_confidence_threshold(); + static const int kConfidenceThresholdFieldNumber = 9; + float confidence_threshold() const; + void set_confidence_threshold(float value); + + // @@protoc_insertion_point(class_scope:caffe.DetectionOutputParameter) + private: + inline void set_has_num_classes(); + inline void clear_has_num_classes(); + inline void set_has_share_location(); + inline void clear_has_share_location(); + inline void set_has_background_label_id(); + inline void clear_has_background_label_id(); + inline void set_has_nms_param(); + inline void clear_has_nms_param(); + inline void set_has_save_output_param(); + inline void clear_has_save_output_param(); + inline void set_has_code_type(); + inline void clear_has_code_type(); + inline void set_has_variance_encoded_in_target(); + inline void clear_has_variance_encoded_in_target(); + inline void set_has_keep_top_k(); + inline void clear_has_keep_top_k(); + inline void set_has_confidence_threshold(); + inline void clear_has_confidence_threshold(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::NonMaximumSuppressionParameter* nms_param_; + ::caffe::SaveOutputParameter* save_output_param_; + ::google::protobuf::uint32 num_classes_; + ::google::protobuf::int32 background_label_id_; + bool variance_encoded_in_target_; + float confidence_threshold_; + ::google::protobuf::int32 keep_top_k_; + bool share_location_; + int code_type_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed DetectionOutputParameter_default_instance_; + +// ------------------------------------------------------------------- + +class Datum : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.Datum) */ { + public: + Datum(); + virtual ~Datum(); + + Datum(const Datum& from); + + inline Datum& operator=(const Datum& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Datum& default_instance(); + + static const Datum* internal_default_instance(); + + void Swap(Datum* other); + + // implements Message ---------------------------------------------- + + inline Datum* New() const { return New(NULL); } + + Datum* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Datum& from); + void MergeFrom(const Datum& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(Datum* other); + void UnsafeMergeFrom(const Datum& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 channels = 1; + bool has_channels() const; + void clear_channels(); + static const int kChannelsFieldNumber = 1; + ::google::protobuf::int32 channels() const; + void set_channels(::google::protobuf::int32 value); + + // optional int32 height = 2; + bool has_height() const; + void clear_height(); + static const int kHeightFieldNumber = 2; + ::google::protobuf::int32 height() const; + void set_height(::google::protobuf::int32 value); + + // optional int32 width = 3; + bool has_width() const; + void clear_width(); + static const int kWidthFieldNumber = 3; + ::google::protobuf::int32 width() const; + void set_width(::google::protobuf::int32 value); + + // optional bytes data = 4; + bool has_data() const; + void clear_data(); + static const int kDataFieldNumber = 4; + const ::std::string& data() const; + void set_data(const ::std::string& value); + void set_data(const char* value); + void set_data(const void* value, size_t size); + ::std::string* mutable_data(); + ::std::string* release_data(); + void set_allocated_data(::std::string* data); + + // optional int32 label = 5; + bool has_label() const; + void clear_label(); + static const int kLabelFieldNumber = 5; + ::google::protobuf::int32 label() const; + void set_label(::google::protobuf::int32 value); + + // repeated float float_data = 6; + int float_data_size() const; + void clear_float_data(); + static const int kFloatDataFieldNumber = 6; + float float_data(int index) const; + void set_float_data(int index, float value); + void add_float_data(float value); + const ::google::protobuf::RepeatedField< float >& + float_data() const; + ::google::protobuf::RepeatedField< float >* + mutable_float_data(); + + // optional bool encoded = 7 [default = false]; + bool has_encoded() const; + void clear_encoded(); + static const int kEncodedFieldNumber = 7; + bool encoded() const; + void set_encoded(bool value); + + // @@protoc_insertion_point(class_scope:caffe.Datum) + private: + inline void set_has_channels(); + inline void clear_has_channels(); + inline void set_has_height(); + inline void clear_has_height(); + inline void set_has_width(); + inline void clear_has_width(); + inline void set_has_data(); + inline void clear_has_data(); + inline void set_has_label(); + inline void clear_has_label(); + inline void set_has_encoded(); + inline void clear_has_encoded(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< float > float_data_; + ::google::protobuf::internal::ArenaStringPtr data_; + ::google::protobuf::int32 channels_; + ::google::protobuf::int32 height_; + ::google::protobuf::int32 width_; + ::google::protobuf::int32 label_; + bool encoded_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed Datum_default_instance_; + +// ------------------------------------------------------------------- + +class FillerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.FillerParameter) */ { + public: + FillerParameter(); + virtual ~FillerParameter(); + + FillerParameter(const FillerParameter& from); + + inline FillerParameter& operator=(const FillerParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FillerParameter& default_instance(); + + static const FillerParameter* internal_default_instance(); + + void Swap(FillerParameter* other); + + // implements Message ---------------------------------------------- + + inline FillerParameter* New() const { return New(NULL); } + + FillerParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FillerParameter& from); + void MergeFrom(const FillerParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FillerParameter* other); + void UnsafeMergeFrom(const FillerParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef FillerParameter_VarianceNorm VarianceNorm; + static const VarianceNorm FAN_IN = + FillerParameter_VarianceNorm_FAN_IN; + static const VarianceNorm FAN_OUT = + FillerParameter_VarianceNorm_FAN_OUT; + static const VarianceNorm AVERAGE = + FillerParameter_VarianceNorm_AVERAGE; + static inline bool VarianceNorm_IsValid(int value) { + return FillerParameter_VarianceNorm_IsValid(value); + } + static const VarianceNorm VarianceNorm_MIN = + FillerParameter_VarianceNorm_VarianceNorm_MIN; + static const VarianceNorm VarianceNorm_MAX = + FillerParameter_VarianceNorm_VarianceNorm_MAX; + static const int VarianceNorm_ARRAYSIZE = + FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + VarianceNorm_descriptor() { + return FillerParameter_VarianceNorm_descriptor(); + } + static inline const ::std::string& VarianceNorm_Name(VarianceNorm value) { + return FillerParameter_VarianceNorm_Name(value); + } + static inline bool VarianceNorm_Parse(const ::std::string& name, + VarianceNorm* value) { + return FillerParameter_VarianceNorm_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional string type = 1 [default = "constant"]; + bool has_type() const; + void clear_type(); + static const int kTypeFieldNumber = 1; + const ::std::string& type() const; + void set_type(const ::std::string& value); + void set_type(const char* value); + void set_type(const char* value, size_t size); + ::std::string* mutable_type(); + ::std::string* release_type(); + void set_allocated_type(::std::string* type); + + // optional float value = 2 [default = 0]; + bool has_value() const; + void clear_value(); + static const int kValueFieldNumber = 2; + float value() const; + void set_value(float value); + + // optional float min = 3 [default = 0]; + bool has_min() const; + void clear_min(); + static const int kMinFieldNumber = 3; + float min() const; + void set_min(float value); + + // optional float max = 4 [default = 1]; + bool has_max() const; + void clear_max(); + static const int kMaxFieldNumber = 4; + float max() const; + void set_max(float value); + + // optional float mean = 5 [default = 0]; + bool has_mean() const; + void clear_mean(); + static const int kMeanFieldNumber = 5; + float mean() const; + void set_mean(float value); + + // optional float std = 6 [default = 1]; + bool has_std() const; + void clear_std(); + static const int kStdFieldNumber = 6; + float std() const; + void set_std(float value); + + // optional int32 sparse = 7 [default = -1]; + bool has_sparse() const; + void clear_sparse(); + static const int kSparseFieldNumber = 7; + ::google::protobuf::int32 sparse() const; + void set_sparse(::google::protobuf::int32 value); + + // optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; + bool has_variance_norm() const; + void clear_variance_norm(); + static const int kVarianceNormFieldNumber = 8; + ::caffe::FillerParameter_VarianceNorm variance_norm() const; + void set_variance_norm(::caffe::FillerParameter_VarianceNorm value); + + // @@protoc_insertion_point(class_scope:caffe.FillerParameter) + private: + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_value(); + inline void clear_has_value(); + inline void set_has_min(); + inline void clear_has_min(); + inline void set_has_max(); + inline void clear_has_max(); + inline void set_has_mean(); + inline void clear_has_mean(); + inline void set_has_std(); + inline void clear_has_std(); + inline void set_has_sparse(); + inline void clear_has_sparse(); + inline void set_has_variance_norm(); + inline void clear_has_variance_norm(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + static ::std::string* _default_type_; + ::google::protobuf::internal::ArenaStringPtr type_; + float value_; + float min_; + float mean_; + int variance_norm_; + ::google::protobuf::int32 sparse_; + float max_; + float std_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed FillerParameter_default_instance_; + +// ------------------------------------------------------------------- + +class NetParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.NetParameter) */ { + public: + NetParameter(); + virtual ~NetParameter(); + + NetParameter(const NetParameter& from); + + inline NetParameter& operator=(const NetParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NetParameter& default_instance(); + + static const NetParameter* internal_default_instance(); + + void Swap(NetParameter* other); + + // implements Message ---------------------------------------------- + + inline NetParameter* New() const { return New(NULL); } + + NetParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NetParameter& from); + void MergeFrom(const NetParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NetParameter* other); + void UnsafeMergeFrom(const NetParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string name = 1; + bool has_name() const; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + + // repeated string input = 3; + int input_size() const; + void clear_input(); + static const int kInputFieldNumber = 3; + const ::std::string& input(int index) const; + ::std::string* mutable_input(int index); + void set_input(int index, const ::std::string& value); + void set_input(int index, const char* value); + void set_input(int index, const char* value, size_t size); + ::std::string* add_input(); + void add_input(const ::std::string& value); + void add_input(const char* value); + void add_input(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input(); + + // repeated .caffe.BlobShape input_shape = 8; + int input_shape_size() const; + void clear_input_shape(); + static const int kInputShapeFieldNumber = 8; + const ::caffe::BlobShape& input_shape(int index) const; + ::caffe::BlobShape* mutable_input_shape(int index); + ::caffe::BlobShape* add_input_shape(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* + mutable_input_shape(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& + input_shape() const; + + // repeated int32 input_dim = 4; + int input_dim_size() const; + void clear_input_dim(); + static const int kInputDimFieldNumber = 4; + ::google::protobuf::int32 input_dim(int index) const; + void set_input_dim(int index, ::google::protobuf::int32 value); + void add_input_dim(::google::protobuf::int32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + input_dim() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_input_dim(); + + // optional bool force_backward = 5 [default = false]; + bool has_force_backward() const; + void clear_force_backward(); + static const int kForceBackwardFieldNumber = 5; + bool force_backward() const; + void set_force_backward(bool value); + + // optional .caffe.NetState state = 6; + bool has_state() const; + void clear_state(); + static const int kStateFieldNumber = 6; + const ::caffe::NetState& state() const; + ::caffe::NetState* mutable_state(); + ::caffe::NetState* release_state(); + void set_allocated_state(::caffe::NetState* state); + + // optional bool debug_info = 7 [default = false]; + bool has_debug_info() const; + void clear_debug_info(); + static const int kDebugInfoFieldNumber = 7; + bool debug_info() const; + void set_debug_info(bool value); + + // repeated .caffe.LayerParameter layer = 100; + int layer_size() const; + void clear_layer(); + static const int kLayerFieldNumber = 100; + const ::caffe::LayerParameter& layer(int index) const; + ::caffe::LayerParameter* mutable_layer(int index); + ::caffe::LayerParameter* add_layer(); + ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >* + mutable_layer(); + const ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >& + layer() const; + + // repeated .caffe.V1LayerParameter layers = 2; + int layers_size() const; + void clear_layers(); + static const int kLayersFieldNumber = 2; + const ::caffe::V1LayerParameter& layers(int index) const; + ::caffe::V1LayerParameter* mutable_layers(int index); + ::caffe::V1LayerParameter* add_layers(); + ::google::protobuf::RepeatedPtrField< ::caffe::V1LayerParameter >* + mutable_layers(); + const ::google::protobuf::RepeatedPtrField< ::caffe::V1LayerParameter >& + layers() const; + + // @@protoc_insertion_point(class_scope:caffe.NetParameter) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_force_backward(); + inline void clear_has_force_backward(); + inline void set_has_state(); + inline void clear_has_state(); + inline void set_has_debug_info(); + inline void clear_has_debug_info(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::std::string> input_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape > input_shape_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > input_dim_; + ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter > layer_; + ::google::protobuf::RepeatedPtrField< ::caffe::V1LayerParameter > layers_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::caffe::NetState* state_; + bool force_backward_; + bool debug_info_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NetParameter_default_instance_; + +// ------------------------------------------------------------------- + +class SolverParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.SolverParameter) */ { + public: + SolverParameter(); + virtual ~SolverParameter(); + + SolverParameter(const SolverParameter& from); + + inline SolverParameter& operator=(const SolverParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SolverParameter& default_instance(); + + static const SolverParameter* internal_default_instance(); + + void Swap(SolverParameter* other); + + // implements Message ---------------------------------------------- + + inline SolverParameter* New() const { return New(NULL); } + + SolverParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SolverParameter& from); + void MergeFrom(const SolverParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SolverParameter* other); + void UnsafeMergeFrom(const SolverParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef SolverParameter_SnapshotFormat SnapshotFormat; + static const SnapshotFormat HDF5 = + SolverParameter_SnapshotFormat_HDF5; + static const SnapshotFormat BINARYPROTO = + SolverParameter_SnapshotFormat_BINARYPROTO; + static inline bool SnapshotFormat_IsValid(int value) { + return SolverParameter_SnapshotFormat_IsValid(value); + } + static const SnapshotFormat SnapshotFormat_MIN = + SolverParameter_SnapshotFormat_SnapshotFormat_MIN; + static const SnapshotFormat SnapshotFormat_MAX = + SolverParameter_SnapshotFormat_SnapshotFormat_MAX; + static const int SnapshotFormat_ARRAYSIZE = + SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + SnapshotFormat_descriptor() { + return SolverParameter_SnapshotFormat_descriptor(); + } + static inline const ::std::string& SnapshotFormat_Name(SnapshotFormat value) { + return SolverParameter_SnapshotFormat_Name(value); + } + static inline bool SnapshotFormat_Parse(const ::std::string& name, + SnapshotFormat* value) { + return SolverParameter_SnapshotFormat_Parse(name, value); + } + + typedef SolverParameter_SolverMode SolverMode; + static const SolverMode CPU = + SolverParameter_SolverMode_CPU; + static const SolverMode GPU = + SolverParameter_SolverMode_GPU; + static inline bool SolverMode_IsValid(int value) { + return SolverParameter_SolverMode_IsValid(value); + } + static const SolverMode SolverMode_MIN = + SolverParameter_SolverMode_SolverMode_MIN; + static const SolverMode SolverMode_MAX = + SolverParameter_SolverMode_SolverMode_MAX; + static const int SolverMode_ARRAYSIZE = + SolverParameter_SolverMode_SolverMode_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + SolverMode_descriptor() { + return SolverParameter_SolverMode_descriptor(); + } + static inline const ::std::string& SolverMode_Name(SolverMode value) { + return SolverParameter_SolverMode_Name(value); + } + static inline bool SolverMode_Parse(const ::std::string& name, + SolverMode* value) { + return SolverParameter_SolverMode_Parse(name, value); + } + + typedef SolverParameter_SolverType SolverType; + static const SolverType SGD = + SolverParameter_SolverType_SGD; + static const SolverType NESTEROV = + SolverParameter_SolverType_NESTEROV; + static const SolverType ADAGRAD = + SolverParameter_SolverType_ADAGRAD; + static const SolverType RMSPROP = + SolverParameter_SolverType_RMSPROP; + static const SolverType ADADELTA = + SolverParameter_SolverType_ADADELTA; + static const SolverType ADAM = + SolverParameter_SolverType_ADAM; + static inline bool SolverType_IsValid(int value) { + return SolverParameter_SolverType_IsValid(value); + } + static const SolverType SolverType_MIN = + SolverParameter_SolverType_SolverType_MIN; + static const SolverType SolverType_MAX = + SolverParameter_SolverType_SolverType_MAX; + static const int SolverType_ARRAYSIZE = + SolverParameter_SolverType_SolverType_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + SolverType_descriptor() { + return SolverParameter_SolverType_descriptor(); + } + static inline const ::std::string& SolverType_Name(SolverType value) { + return SolverParameter_SolverType_Name(value); + } + static inline bool SolverType_Parse(const ::std::string& name, + SolverType* value) { + return SolverParameter_SolverType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional string net = 24; + bool has_net() const; + void clear_net(); + static const int kNetFieldNumber = 24; + const ::std::string& net() const; + void set_net(const ::std::string& value); + void set_net(const char* value); + void set_net(const char* value, size_t size); + ::std::string* mutable_net(); + ::std::string* release_net(); + void set_allocated_net(::std::string* net); + + // optional .caffe.NetParameter net_param = 25; + bool has_net_param() const; + void clear_net_param(); + static const int kNetParamFieldNumber = 25; + const ::caffe::NetParameter& net_param() const; + ::caffe::NetParameter* mutable_net_param(); + ::caffe::NetParameter* release_net_param(); + void set_allocated_net_param(::caffe::NetParameter* net_param); + + // optional string train_net = 1; + bool has_train_net() const; + void clear_train_net(); + static const int kTrainNetFieldNumber = 1; + const ::std::string& train_net() const; + void set_train_net(const ::std::string& value); + void set_train_net(const char* value); + void set_train_net(const char* value, size_t size); + ::std::string* mutable_train_net(); + ::std::string* release_train_net(); + void set_allocated_train_net(::std::string* train_net); + + // repeated string test_net = 2; + int test_net_size() const; + void clear_test_net(); + static const int kTestNetFieldNumber = 2; + const ::std::string& test_net(int index) const; + ::std::string* mutable_test_net(int index); + void set_test_net(int index, const ::std::string& value); + void set_test_net(int index, const char* value); + void set_test_net(int index, const char* value, size_t size); + ::std::string* add_test_net(); + void add_test_net(const ::std::string& value); + void add_test_net(const char* value); + void add_test_net(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& test_net() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_test_net(); + + // optional .caffe.NetParameter train_net_param = 21; + bool has_train_net_param() const; + void clear_train_net_param(); + static const int kTrainNetParamFieldNumber = 21; + const ::caffe::NetParameter& train_net_param() const; + ::caffe::NetParameter* mutable_train_net_param(); + ::caffe::NetParameter* release_train_net_param(); + void set_allocated_train_net_param(::caffe::NetParameter* train_net_param); + + // repeated .caffe.NetParameter test_net_param = 22; + int test_net_param_size() const; + void clear_test_net_param(); + static const int kTestNetParamFieldNumber = 22; + const ::caffe::NetParameter& test_net_param(int index) const; + ::caffe::NetParameter* mutable_test_net_param(int index); + ::caffe::NetParameter* add_test_net_param(); + ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >* + mutable_test_net_param(); + const ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >& + test_net_param() const; + + // optional .caffe.NetState train_state = 26; + bool has_train_state() const; + void clear_train_state(); + static const int kTrainStateFieldNumber = 26; + const ::caffe::NetState& train_state() const; + ::caffe::NetState* mutable_train_state(); + ::caffe::NetState* release_train_state(); + void set_allocated_train_state(::caffe::NetState* train_state); + + // repeated .caffe.NetState test_state = 27; + int test_state_size() const; + void clear_test_state(); + static const int kTestStateFieldNumber = 27; + const ::caffe::NetState& test_state(int index) const; + ::caffe::NetState* mutable_test_state(int index); + ::caffe::NetState* add_test_state(); + ::google::protobuf::RepeatedPtrField< ::caffe::NetState >* + mutable_test_state(); + const ::google::protobuf::RepeatedPtrField< ::caffe::NetState >& + test_state() const; + + // repeated int32 test_iter = 3; + int test_iter_size() const; + void clear_test_iter(); + static const int kTestIterFieldNumber = 3; + ::google::protobuf::int32 test_iter(int index) const; + void set_test_iter(int index, ::google::protobuf::int32 value); + void add_test_iter(::google::protobuf::int32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + test_iter() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_test_iter(); + + // optional int32 test_interval = 4 [default = 0]; + bool has_test_interval() const; + void clear_test_interval(); + static const int kTestIntervalFieldNumber = 4; + ::google::protobuf::int32 test_interval() const; + void set_test_interval(::google::protobuf::int32 value); + + // optional bool test_compute_loss = 19 [default = false]; + bool has_test_compute_loss() const; + void clear_test_compute_loss(); + static const int kTestComputeLossFieldNumber = 19; + bool test_compute_loss() const; + void set_test_compute_loss(bool value); + + // optional bool test_initialization = 32 [default = true]; + bool has_test_initialization() const; + void clear_test_initialization(); + static const int kTestInitializationFieldNumber = 32; + bool test_initialization() const; + void set_test_initialization(bool value); + + // optional float base_lr = 5; + bool has_base_lr() const; + void clear_base_lr(); + static const int kBaseLrFieldNumber = 5; + float base_lr() const; + void set_base_lr(float value); + + // optional int32 display = 6; + bool has_display() const; + void clear_display(); + static const int kDisplayFieldNumber = 6; + ::google::protobuf::int32 display() const; + void set_display(::google::protobuf::int32 value); + + // optional int32 average_loss = 33 [default = 1]; + bool has_average_loss() const; + void clear_average_loss(); + static const int kAverageLossFieldNumber = 33; + ::google::protobuf::int32 average_loss() const; + void set_average_loss(::google::protobuf::int32 value); + + // optional int32 max_iter = 7; + bool has_max_iter() const; + void clear_max_iter(); + static const int kMaxIterFieldNumber = 7; + ::google::protobuf::int32 max_iter() const; + void set_max_iter(::google::protobuf::int32 value); + + // optional int32 iter_size = 36 [default = 1]; + bool has_iter_size() const; + void clear_iter_size(); + static const int kIterSizeFieldNumber = 36; + ::google::protobuf::int32 iter_size() const; + void set_iter_size(::google::protobuf::int32 value); + + // optional string lr_policy = 8; + bool has_lr_policy() const; + void clear_lr_policy(); + static const int kLrPolicyFieldNumber = 8; + const ::std::string& lr_policy() const; + void set_lr_policy(const ::std::string& value); + void set_lr_policy(const char* value); + void set_lr_policy(const char* value, size_t size); + ::std::string* mutable_lr_policy(); + ::std::string* release_lr_policy(); + void set_allocated_lr_policy(::std::string* lr_policy); + + // optional float gamma = 9; + bool has_gamma() const; + void clear_gamma(); + static const int kGammaFieldNumber = 9; + float gamma() const; + void set_gamma(float value); + + // optional float power = 10; + bool has_power() const; + void clear_power(); + static const int kPowerFieldNumber = 10; + float power() const; + void set_power(float value); + + // optional float momentum = 11; + bool has_momentum() const; + void clear_momentum(); + static const int kMomentumFieldNumber = 11; + float momentum() const; + void set_momentum(float value); + + // optional float weight_decay = 12; + bool has_weight_decay() const; + void clear_weight_decay(); + static const int kWeightDecayFieldNumber = 12; + float weight_decay() const; + void set_weight_decay(float value); + + // optional string regularization_type = 29 [default = "L2"]; + bool has_regularization_type() const; + void clear_regularization_type(); + static const int kRegularizationTypeFieldNumber = 29; + const ::std::string& regularization_type() const; + void set_regularization_type(const ::std::string& value); + void set_regularization_type(const char* value); + void set_regularization_type(const char* value, size_t size); + ::std::string* mutable_regularization_type(); + ::std::string* release_regularization_type(); + void set_allocated_regularization_type(::std::string* regularization_type); + + // optional int32 stepsize = 13; + bool has_stepsize() const; + void clear_stepsize(); + static const int kStepsizeFieldNumber = 13; + ::google::protobuf::int32 stepsize() const; + void set_stepsize(::google::protobuf::int32 value); + + // repeated int32 stepvalue = 34; + int stepvalue_size() const; + void clear_stepvalue(); + static const int kStepvalueFieldNumber = 34; + ::google::protobuf::int32 stepvalue(int index) const; + void set_stepvalue(int index, ::google::protobuf::int32 value); + void add_stepvalue(::google::protobuf::int32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + stepvalue() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_stepvalue(); + + // optional float clip_gradients = 35 [default = -1]; + bool has_clip_gradients() const; + void clear_clip_gradients(); + static const int kClipGradientsFieldNumber = 35; + float clip_gradients() const; + void set_clip_gradients(float value); + + // optional int32 snapshot = 14 [default = 0]; + bool has_snapshot() const; + void clear_snapshot(); + static const int kSnapshotFieldNumber = 14; + ::google::protobuf::int32 snapshot() const; + void set_snapshot(::google::protobuf::int32 value); + + // optional string snapshot_prefix = 15; + bool has_snapshot_prefix() const; + void clear_snapshot_prefix(); + static const int kSnapshotPrefixFieldNumber = 15; + const ::std::string& snapshot_prefix() const; + void set_snapshot_prefix(const ::std::string& value); + void set_snapshot_prefix(const char* value); + void set_snapshot_prefix(const char* value, size_t size); + ::std::string* mutable_snapshot_prefix(); + ::std::string* release_snapshot_prefix(); + void set_allocated_snapshot_prefix(::std::string* snapshot_prefix); + + // optional bool snapshot_diff = 16 [default = false]; + bool has_snapshot_diff() const; + void clear_snapshot_diff(); + static const int kSnapshotDiffFieldNumber = 16; + bool snapshot_diff() const; + void set_snapshot_diff(bool value); + + // optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + bool has_snapshot_format() const; + void clear_snapshot_format(); + static const int kSnapshotFormatFieldNumber = 37; + ::caffe::SolverParameter_SnapshotFormat snapshot_format() const; + void set_snapshot_format(::caffe::SolverParameter_SnapshotFormat value); + + // optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; + bool has_solver_mode() const; + void clear_solver_mode(); + static const int kSolverModeFieldNumber = 17; + ::caffe::SolverParameter_SolverMode solver_mode() const; + void set_solver_mode(::caffe::SolverParameter_SolverMode value); + + // optional int32 device_id = 18 [default = 0]; + bool has_device_id() const; + void clear_device_id(); + static const int kDeviceIdFieldNumber = 18; + ::google::protobuf::int32 device_id() const; + void set_device_id(::google::protobuf::int32 value); + + // optional int64 random_seed = 20 [default = -1]; + bool has_random_seed() const; + void clear_random_seed(); + static const int kRandomSeedFieldNumber = 20; + ::google::protobuf::int64 random_seed() const; + void set_random_seed(::google::protobuf::int64 value); + + // optional string type = 40 [default = "SGD"]; + bool has_type() const; + void clear_type(); + static const int kTypeFieldNumber = 40; + const ::std::string& type() const; + void set_type(const ::std::string& value); + void set_type(const char* value); + void set_type(const char* value, size_t size); + ::std::string* mutable_type(); + ::std::string* release_type(); + void set_allocated_type(::std::string* type); + + // optional float delta = 31 [default = 1e-08]; + bool has_delta() const; + void clear_delta(); + static const int kDeltaFieldNumber = 31; + float delta() const; + void set_delta(float value); + + // optional float momentum2 = 39 [default = 0.999]; + bool has_momentum2() const; + void clear_momentum2(); + static const int kMomentum2FieldNumber = 39; + float momentum2() const; + void set_momentum2(float value); + + // optional float rms_decay = 38 [default = 0.99]; + bool has_rms_decay() const; + void clear_rms_decay(); + static const int kRmsDecayFieldNumber = 38; + float rms_decay() const; + void set_rms_decay(float value); + + // optional bool debug_info = 23 [default = false]; + bool has_debug_info() const; + void clear_debug_info(); + static const int kDebugInfoFieldNumber = 23; + bool debug_info() const; + void set_debug_info(bool value); + + // optional bool snapshot_after_train = 28 [default = true]; + bool has_snapshot_after_train() const; + void clear_snapshot_after_train(); + static const int kSnapshotAfterTrainFieldNumber = 28; + bool snapshot_after_train() const; + void set_snapshot_after_train(bool value); + + // optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; + bool has_solver_type() const; + void clear_solver_type(); + static const int kSolverTypeFieldNumber = 30; + ::caffe::SolverParameter_SolverType solver_type() const; + void set_solver_type(::caffe::SolverParameter_SolverType value); + + // @@protoc_insertion_point(class_scope:caffe.SolverParameter) + private: + inline void set_has_net(); + inline void clear_has_net(); + inline void set_has_net_param(); + inline void clear_has_net_param(); + inline void set_has_train_net(); + inline void clear_has_train_net(); + inline void set_has_train_net_param(); + inline void clear_has_train_net_param(); + inline void set_has_train_state(); + inline void clear_has_train_state(); + inline void set_has_test_interval(); + inline void clear_has_test_interval(); + inline void set_has_test_compute_loss(); + inline void clear_has_test_compute_loss(); + inline void set_has_test_initialization(); + inline void clear_has_test_initialization(); + inline void set_has_base_lr(); + inline void clear_has_base_lr(); + inline void set_has_display(); + inline void clear_has_display(); + inline void set_has_average_loss(); + inline void clear_has_average_loss(); + inline void set_has_max_iter(); + inline void clear_has_max_iter(); + inline void set_has_iter_size(); + inline void clear_has_iter_size(); + inline void set_has_lr_policy(); + inline void clear_has_lr_policy(); + inline void set_has_gamma(); + inline void clear_has_gamma(); + inline void set_has_power(); + inline void clear_has_power(); + inline void set_has_momentum(); + inline void clear_has_momentum(); + inline void set_has_weight_decay(); + inline void clear_has_weight_decay(); + inline void set_has_regularization_type(); + inline void clear_has_regularization_type(); + inline void set_has_stepsize(); + inline void clear_has_stepsize(); + inline void set_has_clip_gradients(); + inline void clear_has_clip_gradients(); + inline void set_has_snapshot(); + inline void clear_has_snapshot(); + inline void set_has_snapshot_prefix(); + inline void clear_has_snapshot_prefix(); + inline void set_has_snapshot_diff(); + inline void clear_has_snapshot_diff(); + inline void set_has_snapshot_format(); + inline void clear_has_snapshot_format(); + inline void set_has_solver_mode(); + inline void clear_has_solver_mode(); + inline void set_has_device_id(); + inline void clear_has_device_id(); + inline void set_has_random_seed(); + inline void clear_has_random_seed(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_delta(); + inline void clear_has_delta(); + inline void set_has_momentum2(); + inline void clear_has_momentum2(); + inline void set_has_rms_decay(); + inline void clear_has_rms_decay(); + inline void set_has_debug_info(); + inline void clear_has_debug_info(); + inline void set_has_snapshot_after_train(); + inline void clear_has_snapshot_after_train(); + inline void set_has_solver_type(); + inline void clear_has_solver_type(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<2> _has_bits_; + ::google::protobuf::RepeatedPtrField< ::std::string> test_net_; + ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter > test_net_param_; + ::google::protobuf::RepeatedPtrField< ::caffe::NetState > test_state_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > test_iter_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > stepvalue_; + ::google::protobuf::internal::ArenaStringPtr net_; + ::google::protobuf::internal::ArenaStringPtr train_net_; + ::google::protobuf::internal::ArenaStringPtr lr_policy_; + static ::std::string* _default_regularization_type_; + ::google::protobuf::internal::ArenaStringPtr regularization_type_; + ::google::protobuf::internal::ArenaStringPtr snapshot_prefix_; + static ::std::string* _default_type_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::caffe::NetParameter* net_param_; + ::caffe::NetParameter* train_net_param_; + ::caffe::NetState* train_state_; + ::google::protobuf::int32 test_interval_; + float base_lr_; + ::google::protobuf::int32 display_; + ::google::protobuf::int32 max_iter_; + float gamma_; + float power_; + float momentum_; + float weight_decay_; + ::google::protobuf::int32 stepsize_; + bool test_compute_loss_; + bool snapshot_diff_; + bool debug_info_; + ::google::protobuf::int32 snapshot_; + ::google::protobuf::int32 device_id_; + int solver_type_; + float rms_decay_; + ::google::protobuf::int32 average_loss_; + ::google::protobuf::int32 iter_size_; + bool test_initialization_; + bool snapshot_after_train_; + float clip_gradients_; + int snapshot_format_; + int solver_mode_; + ::google::protobuf::int64 random_seed_; + float delta_; + float momentum2_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed SolverParameter_default_instance_; + +// ------------------------------------------------------------------- + +class SolverState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.SolverState) */ { + public: + SolverState(); + virtual ~SolverState(); + + SolverState(const SolverState& from); + + inline SolverState& operator=(const SolverState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SolverState& default_instance(); + + static const SolverState* internal_default_instance(); + + void Swap(SolverState* other); + + // implements Message ---------------------------------------------- + + inline SolverState* New() const { return New(NULL); } + + SolverState* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SolverState& from); + void MergeFrom(const SolverState& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SolverState* other); + void UnsafeMergeFrom(const SolverState& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 iter = 1; + bool has_iter() const; + void clear_iter(); + static const int kIterFieldNumber = 1; + ::google::protobuf::int32 iter() const; + void set_iter(::google::protobuf::int32 value); + + // optional string learned_net = 2; + bool has_learned_net() const; + void clear_learned_net(); + static const int kLearnedNetFieldNumber = 2; + const ::std::string& learned_net() const; + void set_learned_net(const ::std::string& value); + void set_learned_net(const char* value); + void set_learned_net(const char* value, size_t size); + ::std::string* mutable_learned_net(); + ::std::string* release_learned_net(); + void set_allocated_learned_net(::std::string* learned_net); + + // repeated .caffe.BlobProto history = 3; + int history_size() const; + void clear_history(); + static const int kHistoryFieldNumber = 3; + const ::caffe::BlobProto& history(int index) const; + ::caffe::BlobProto* mutable_history(int index); + ::caffe::BlobProto* add_history(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* + mutable_history(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& + history() const; + + // optional int32 current_step = 4 [default = 0]; + bool has_current_step() const; + void clear_current_step(); + static const int kCurrentStepFieldNumber = 4; + ::google::protobuf::int32 current_step() const; + void set_current_step(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.SolverState) + private: + inline void set_has_iter(); + inline void clear_has_iter(); + inline void set_has_learned_net(); + inline void clear_has_learned_net(); + inline void set_has_current_step(); + inline void clear_has_current_step(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > history_; + ::google::protobuf::internal::ArenaStringPtr learned_net_; + ::google::protobuf::int32 iter_; + ::google::protobuf::int32 current_step_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed SolverState_default_instance_; + +// ------------------------------------------------------------------- + +class NetState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.NetState) */ { + public: + NetState(); + virtual ~NetState(); + + NetState(const NetState& from); + + inline NetState& operator=(const NetState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NetState& default_instance(); + + static const NetState* internal_default_instance(); + + void Swap(NetState* other); + + // implements Message ---------------------------------------------- + + inline NetState* New() const { return New(NULL); } + + NetState* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NetState& from); + void MergeFrom(const NetState& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NetState* other); + void UnsafeMergeFrom(const NetState& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .caffe.Phase phase = 1 [default = TEST]; + bool has_phase() const; + void clear_phase(); + static const int kPhaseFieldNumber = 1; + ::caffe::Phase phase() const; + void set_phase(::caffe::Phase value); + + // optional int32 level = 2 [default = 0]; + bool has_level() const; + void clear_level(); + static const int kLevelFieldNumber = 2; + ::google::protobuf::int32 level() const; + void set_level(::google::protobuf::int32 value); + + // repeated string stage = 3; + int stage_size() const; + void clear_stage(); + static const int kStageFieldNumber = 3; + const ::std::string& stage(int index) const; + ::std::string* mutable_stage(int index); + void set_stage(int index, const ::std::string& value); + void set_stage(int index, const char* value); + void set_stage(int index, const char* value, size_t size); + ::std::string* add_stage(); + void add_stage(const ::std::string& value); + void add_stage(const char* value); + void add_stage(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& stage() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_stage(); + + // @@protoc_insertion_point(class_scope:caffe.NetState) + private: + inline void set_has_phase(); + inline void clear_has_phase(); + inline void set_has_level(); + inline void clear_has_level(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::std::string> stage_; + ::google::protobuf::int32 level_; + int phase_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NetState_default_instance_; + +// ------------------------------------------------------------------- + +class NetStateRule : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.NetStateRule) */ { + public: + NetStateRule(); + virtual ~NetStateRule(); + + NetStateRule(const NetStateRule& from); + + inline NetStateRule& operator=(const NetStateRule& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NetStateRule& default_instance(); + + static const NetStateRule* internal_default_instance(); + + void Swap(NetStateRule* other); + + // implements Message ---------------------------------------------- + + inline NetStateRule* New() const { return New(NULL); } + + NetStateRule* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NetStateRule& from); + void MergeFrom(const NetStateRule& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NetStateRule* other); + void UnsafeMergeFrom(const NetStateRule& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .caffe.Phase phase = 1; + bool has_phase() const; + void clear_phase(); + static const int kPhaseFieldNumber = 1; + ::caffe::Phase phase() const; + void set_phase(::caffe::Phase value); + + // optional int32 min_level = 2; + bool has_min_level() const; + void clear_min_level(); + static const int kMinLevelFieldNumber = 2; + ::google::protobuf::int32 min_level() const; + void set_min_level(::google::protobuf::int32 value); + + // optional int32 max_level = 3; + bool has_max_level() const; + void clear_max_level(); + static const int kMaxLevelFieldNumber = 3; + ::google::protobuf::int32 max_level() const; + void set_max_level(::google::protobuf::int32 value); + + // repeated string stage = 4; + int stage_size() const; + void clear_stage(); + static const int kStageFieldNumber = 4; + const ::std::string& stage(int index) const; + ::std::string* mutable_stage(int index); + void set_stage(int index, const ::std::string& value); + void set_stage(int index, const char* value); + void set_stage(int index, const char* value, size_t size); + ::std::string* add_stage(); + void add_stage(const ::std::string& value); + void add_stage(const char* value); + void add_stage(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& stage() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_stage(); + + // repeated string not_stage = 5; + int not_stage_size() const; + void clear_not_stage(); + static const int kNotStageFieldNumber = 5; + const ::std::string& not_stage(int index) const; + ::std::string* mutable_not_stage(int index); + void set_not_stage(int index, const ::std::string& value); + void set_not_stage(int index, const char* value); + void set_not_stage(int index, const char* value, size_t size); + ::std::string* add_not_stage(); + void add_not_stage(const ::std::string& value); + void add_not_stage(const char* value); + void add_not_stage(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& not_stage() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_not_stage(); + + // @@protoc_insertion_point(class_scope:caffe.NetStateRule) + private: + inline void set_has_phase(); + inline void clear_has_phase(); + inline void set_has_min_level(); + inline void clear_has_min_level(); + inline void set_has_max_level(); + inline void clear_has_max_level(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::std::string> stage_; + ::google::protobuf::RepeatedPtrField< ::std::string> not_stage_; + int phase_; + ::google::protobuf::int32 min_level_; + ::google::protobuf::int32 max_level_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NetStateRule_default_instance_; + +// ------------------------------------------------------------------- + +class ParamSpec : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ParamSpec) */ { + public: + ParamSpec(); + virtual ~ParamSpec(); + + ParamSpec(const ParamSpec& from); + + inline ParamSpec& operator=(const ParamSpec& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ParamSpec& default_instance(); + + static const ParamSpec* internal_default_instance(); + + void Swap(ParamSpec* other); + + // implements Message ---------------------------------------------- + + inline ParamSpec* New() const { return New(NULL); } + + ParamSpec* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ParamSpec& from); + void MergeFrom(const ParamSpec& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ParamSpec* other); + void UnsafeMergeFrom(const ParamSpec& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef ParamSpec_DimCheckMode DimCheckMode; + static const DimCheckMode STRICT = + ParamSpec_DimCheckMode_STRICT; + static const DimCheckMode PERMISSIVE = + ParamSpec_DimCheckMode_PERMISSIVE; + static inline bool DimCheckMode_IsValid(int value) { + return ParamSpec_DimCheckMode_IsValid(value); + } + static const DimCheckMode DimCheckMode_MIN = + ParamSpec_DimCheckMode_DimCheckMode_MIN; + static const DimCheckMode DimCheckMode_MAX = + ParamSpec_DimCheckMode_DimCheckMode_MAX; + static const int DimCheckMode_ARRAYSIZE = + ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + DimCheckMode_descriptor() { + return ParamSpec_DimCheckMode_descriptor(); + } + static inline const ::std::string& DimCheckMode_Name(DimCheckMode value) { + return ParamSpec_DimCheckMode_Name(value); + } + static inline bool DimCheckMode_Parse(const ::std::string& name, + DimCheckMode* value) { + return ParamSpec_DimCheckMode_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional string name = 1; + bool has_name() const; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + + // optional .caffe.ParamSpec.DimCheckMode share_mode = 2; + bool has_share_mode() const; + void clear_share_mode(); + static const int kShareModeFieldNumber = 2; + ::caffe::ParamSpec_DimCheckMode share_mode() const; + void set_share_mode(::caffe::ParamSpec_DimCheckMode value); + + // optional float lr_mult = 3 [default = 1]; + bool has_lr_mult() const; + void clear_lr_mult(); + static const int kLrMultFieldNumber = 3; + float lr_mult() const; + void set_lr_mult(float value); + + // optional float decay_mult = 4 [default = 1]; + bool has_decay_mult() const; + void clear_decay_mult(); + static const int kDecayMultFieldNumber = 4; + float decay_mult() const; + void set_decay_mult(float value); + + // @@protoc_insertion_point(class_scope:caffe.ParamSpec) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_share_mode(); + inline void clear_has_share_mode(); + inline void set_has_lr_mult(); + inline void clear_has_lr_mult(); + inline void set_has_decay_mult(); + inline void clear_has_decay_mult(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr name_; + int share_mode_; + float lr_mult_; + float decay_mult_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ParamSpec_default_instance_; + +// ------------------------------------------------------------------- + +class LayerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.LayerParameter) */ { + public: + LayerParameter(); + virtual ~LayerParameter(); + + LayerParameter(const LayerParameter& from); + + inline LayerParameter& operator=(const LayerParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LayerParameter& default_instance(); + + static const LayerParameter* internal_default_instance(); + + void Swap(LayerParameter* other); + + // implements Message ---------------------------------------------- + + inline LayerParameter* New() const { return New(NULL); } + + LayerParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LayerParameter& from); + void MergeFrom(const LayerParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LayerParameter* other); + void UnsafeMergeFrom(const LayerParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string name = 1; + bool has_name() const; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + + // optional string type = 2; + bool has_type() const; + void clear_type(); + static const int kTypeFieldNumber = 2; + const ::std::string& type() const; + void set_type(const ::std::string& value); + void set_type(const char* value); + void set_type(const char* value, size_t size); + ::std::string* mutable_type(); + ::std::string* release_type(); + void set_allocated_type(::std::string* type); + + // repeated string bottom = 3; + int bottom_size() const; + void clear_bottom(); + static const int kBottomFieldNumber = 3; + const ::std::string& bottom(int index) const; + ::std::string* mutable_bottom(int index); + void set_bottom(int index, const ::std::string& value); + void set_bottom(int index, const char* value); + void set_bottom(int index, const char* value, size_t size); + ::std::string* add_bottom(); + void add_bottom(const ::std::string& value); + void add_bottom(const char* value); + void add_bottom(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& bottom() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_bottom(); + + // repeated string top = 4; + int top_size() const; + void clear_top(); + static const int kTopFieldNumber = 4; + const ::std::string& top(int index) const; + ::std::string* mutable_top(int index); + void set_top(int index, const ::std::string& value); + void set_top(int index, const char* value); + void set_top(int index, const char* value, size_t size); + ::std::string* add_top(); + void add_top(const ::std::string& value); + void add_top(const char* value); + void add_top(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& top() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_top(); + + // optional .caffe.Phase phase = 10; + bool has_phase() const; + void clear_phase(); + static const int kPhaseFieldNumber = 10; + ::caffe::Phase phase() const; + void set_phase(::caffe::Phase value); + + // repeated float loss_weight = 5; + int loss_weight_size() const; + void clear_loss_weight(); + static const int kLossWeightFieldNumber = 5; + float loss_weight(int index) const; + void set_loss_weight(int index, float value); + void add_loss_weight(float value); + const ::google::protobuf::RepeatedField< float >& + loss_weight() const; + ::google::protobuf::RepeatedField< float >* + mutable_loss_weight(); + + // repeated .caffe.ParamSpec param = 6; + int param_size() const; + void clear_param(); + static const int kParamFieldNumber = 6; + const ::caffe::ParamSpec& param(int index) const; + ::caffe::ParamSpec* mutable_param(int index); + ::caffe::ParamSpec* add_param(); + ::google::protobuf::RepeatedPtrField< ::caffe::ParamSpec >* + mutable_param(); + const ::google::protobuf::RepeatedPtrField< ::caffe::ParamSpec >& + param() const; + + // repeated .caffe.BlobProto blobs = 7; + int blobs_size() const; + void clear_blobs(); + static const int kBlobsFieldNumber = 7; + const ::caffe::BlobProto& blobs(int index) const; + ::caffe::BlobProto* mutable_blobs(int index); + ::caffe::BlobProto* add_blobs(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* + mutable_blobs(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& + blobs() const; + + // repeated bool propagate_down = 11; + int propagate_down_size() const; + void clear_propagate_down(); + static const int kPropagateDownFieldNumber = 11; + bool propagate_down(int index) const; + void set_propagate_down(int index, bool value); + void add_propagate_down(bool value); + const ::google::protobuf::RepeatedField< bool >& + propagate_down() const; + ::google::protobuf::RepeatedField< bool >* + mutable_propagate_down(); + + // repeated .caffe.NetStateRule include = 8; + int include_size() const; + void clear_include(); + static const int kIncludeFieldNumber = 8; + const ::caffe::NetStateRule& include(int index) const; + ::caffe::NetStateRule* mutable_include(int index); + ::caffe::NetStateRule* add_include(); + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* + mutable_include(); + const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& + include() const; + + // repeated .caffe.NetStateRule exclude = 9; + int exclude_size() const; + void clear_exclude(); + static const int kExcludeFieldNumber = 9; + const ::caffe::NetStateRule& exclude(int index) const; + ::caffe::NetStateRule* mutable_exclude(int index); + ::caffe::NetStateRule* add_exclude(); + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* + mutable_exclude(); + const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& + exclude() const; + + // optional .caffe.TransformationParameter transform_param = 100; + bool has_transform_param() const; + void clear_transform_param(); + static const int kTransformParamFieldNumber = 100; + const ::caffe::TransformationParameter& transform_param() const; + ::caffe::TransformationParameter* mutable_transform_param(); + ::caffe::TransformationParameter* release_transform_param(); + void set_allocated_transform_param(::caffe::TransformationParameter* transform_param); + + // optional .caffe.LossParameter loss_param = 101; + bool has_loss_param() const; + void clear_loss_param(); + static const int kLossParamFieldNumber = 101; + const ::caffe::LossParameter& loss_param() const; + ::caffe::LossParameter* mutable_loss_param(); + ::caffe::LossParameter* release_loss_param(); + void set_allocated_loss_param(::caffe::LossParameter* loss_param); + + // optional .caffe.AccuracyParameter accuracy_param = 102; + bool has_accuracy_param() const; + void clear_accuracy_param(); + static const int kAccuracyParamFieldNumber = 102; + const ::caffe::AccuracyParameter& accuracy_param() const; + ::caffe::AccuracyParameter* mutable_accuracy_param(); + ::caffe::AccuracyParameter* release_accuracy_param(); + void set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param); + + // optional .caffe.ArgMaxParameter argmax_param = 103; + bool has_argmax_param() const; + void clear_argmax_param(); + static const int kArgmaxParamFieldNumber = 103; + const ::caffe::ArgMaxParameter& argmax_param() const; + ::caffe::ArgMaxParameter* mutable_argmax_param(); + ::caffe::ArgMaxParameter* release_argmax_param(); + void set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param); + + // optional .caffe.BatchNormParameter batch_norm_param = 139; + bool has_batch_norm_param() const; + void clear_batch_norm_param(); + static const int kBatchNormParamFieldNumber = 139; + const ::caffe::BatchNormParameter& batch_norm_param() const; + ::caffe::BatchNormParameter* mutable_batch_norm_param(); + ::caffe::BatchNormParameter* release_batch_norm_param(); + void set_allocated_batch_norm_param(::caffe::BatchNormParameter* batch_norm_param); + + // optional .caffe.BiasParameter bias_param = 141; + bool has_bias_param() const; + void clear_bias_param(); + static const int kBiasParamFieldNumber = 141; + const ::caffe::BiasParameter& bias_param() const; + ::caffe::BiasParameter* mutable_bias_param(); + ::caffe::BiasParameter* release_bias_param(); + void set_allocated_bias_param(::caffe::BiasParameter* bias_param); + + // optional .caffe.ConcatParameter concat_param = 104; + bool has_concat_param() const; + void clear_concat_param(); + static const int kConcatParamFieldNumber = 104; + const ::caffe::ConcatParameter& concat_param() const; + ::caffe::ConcatParameter* mutable_concat_param(); + ::caffe::ConcatParameter* release_concat_param(); + void set_allocated_concat_param(::caffe::ConcatParameter* concat_param); + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105; + bool has_contrastive_loss_param() const; + void clear_contrastive_loss_param(); + static const int kContrastiveLossParamFieldNumber = 105; + const ::caffe::ContrastiveLossParameter& contrastive_loss_param() const; + ::caffe::ContrastiveLossParameter* mutable_contrastive_loss_param(); + ::caffe::ContrastiveLossParameter* release_contrastive_loss_param(); + void set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param); + + // optional .caffe.ConvolutionParameter convolution_param = 106; + bool has_convolution_param() const; + void clear_convolution_param(); + static const int kConvolutionParamFieldNumber = 106; + const ::caffe::ConvolutionParameter& convolution_param() const; + ::caffe::ConvolutionParameter* mutable_convolution_param(); + ::caffe::ConvolutionParameter* release_convolution_param(); + void set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param); + + // optional .caffe.CropParameter crop_param = 144; + bool has_crop_param() const; + void clear_crop_param(); + static const int kCropParamFieldNumber = 144; + const ::caffe::CropParameter& crop_param() const; + ::caffe::CropParameter* mutable_crop_param(); + ::caffe::CropParameter* release_crop_param(); + void set_allocated_crop_param(::caffe::CropParameter* crop_param); + + // optional .caffe.DataParameter data_param = 107; + bool has_data_param() const; + void clear_data_param(); + static const int kDataParamFieldNumber = 107; + const ::caffe::DataParameter& data_param() const; + ::caffe::DataParameter* mutable_data_param(); + ::caffe::DataParameter* release_data_param(); + void set_allocated_data_param(::caffe::DataParameter* data_param); + + // optional .caffe.DetectionOutputParameter detection_output_param = 147; + bool has_detection_output_param() const; + void clear_detection_output_param(); + static const int kDetectionOutputParamFieldNumber = 147; + const ::caffe::DetectionOutputParameter& detection_output_param() const; + ::caffe::DetectionOutputParameter* mutable_detection_output_param(); + ::caffe::DetectionOutputParameter* release_detection_output_param(); + void set_allocated_detection_output_param(::caffe::DetectionOutputParameter* detection_output_param); + + // optional .caffe.DropoutParameter dropout_param = 108; + bool has_dropout_param() const; + void clear_dropout_param(); + static const int kDropoutParamFieldNumber = 108; + const ::caffe::DropoutParameter& dropout_param() const; + ::caffe::DropoutParameter* mutable_dropout_param(); + ::caffe::DropoutParameter* release_dropout_param(); + void set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param); + + // optional .caffe.DummyDataParameter dummy_data_param = 109; + bool has_dummy_data_param() const; + void clear_dummy_data_param(); + static const int kDummyDataParamFieldNumber = 109; + const ::caffe::DummyDataParameter& dummy_data_param() const; + ::caffe::DummyDataParameter* mutable_dummy_data_param(); + ::caffe::DummyDataParameter* release_dummy_data_param(); + void set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param); + + // optional .caffe.EltwiseParameter eltwise_param = 110; + bool has_eltwise_param() const; + void clear_eltwise_param(); + static const int kEltwiseParamFieldNumber = 110; + const ::caffe::EltwiseParameter& eltwise_param() const; + ::caffe::EltwiseParameter* mutable_eltwise_param(); + ::caffe::EltwiseParameter* release_eltwise_param(); + void set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param); + + // optional .caffe.ELUParameter elu_param = 140; + bool has_elu_param() const; + void clear_elu_param(); + static const int kEluParamFieldNumber = 140; + const ::caffe::ELUParameter& elu_param() const; + ::caffe::ELUParameter* mutable_elu_param(); + ::caffe::ELUParameter* release_elu_param(); + void set_allocated_elu_param(::caffe::ELUParameter* elu_param); + + // optional .caffe.EmbedParameter embed_param = 137; + bool has_embed_param() const; + void clear_embed_param(); + static const int kEmbedParamFieldNumber = 137; + const ::caffe::EmbedParameter& embed_param() const; + ::caffe::EmbedParameter* mutable_embed_param(); + ::caffe::EmbedParameter* release_embed_param(); + void set_allocated_embed_param(::caffe::EmbedParameter* embed_param); + + // optional .caffe.ExpParameter exp_param = 111; + bool has_exp_param() const; + void clear_exp_param(); + static const int kExpParamFieldNumber = 111; + const ::caffe::ExpParameter& exp_param() const; + ::caffe::ExpParameter* mutable_exp_param(); + ::caffe::ExpParameter* release_exp_param(); + void set_allocated_exp_param(::caffe::ExpParameter* exp_param); + + // optional .caffe.FlattenParameter flatten_param = 135; + bool has_flatten_param() const; + void clear_flatten_param(); + static const int kFlattenParamFieldNumber = 135; + const ::caffe::FlattenParameter& flatten_param() const; + ::caffe::FlattenParameter* mutable_flatten_param(); + ::caffe::FlattenParameter* release_flatten_param(); + void set_allocated_flatten_param(::caffe::FlattenParameter* flatten_param); + + // optional .caffe.HDF5DataParameter hdf5_data_param = 112; + bool has_hdf5_data_param() const; + void clear_hdf5_data_param(); + static const int kHdf5DataParamFieldNumber = 112; + const ::caffe::HDF5DataParameter& hdf5_data_param() const; + ::caffe::HDF5DataParameter* mutable_hdf5_data_param(); + ::caffe::HDF5DataParameter* release_hdf5_data_param(); + void set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param); + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 113; + bool has_hdf5_output_param() const; + void clear_hdf5_output_param(); + static const int kHdf5OutputParamFieldNumber = 113; + const ::caffe::HDF5OutputParameter& hdf5_output_param() const; + ::caffe::HDF5OutputParameter* mutable_hdf5_output_param(); + ::caffe::HDF5OutputParameter* release_hdf5_output_param(); + void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param); + + // optional .caffe.HingeLossParameter hinge_loss_param = 114; + bool has_hinge_loss_param() const; + void clear_hinge_loss_param(); + static const int kHingeLossParamFieldNumber = 114; + const ::caffe::HingeLossParameter& hinge_loss_param() const; + ::caffe::HingeLossParameter* mutable_hinge_loss_param(); + ::caffe::HingeLossParameter* release_hinge_loss_param(); + void set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param); + + // optional .caffe.ImageDataParameter image_data_param = 115; + bool has_image_data_param() const; + void clear_image_data_param(); + static const int kImageDataParamFieldNumber = 115; + const ::caffe::ImageDataParameter& image_data_param() const; + ::caffe::ImageDataParameter* mutable_image_data_param(); + ::caffe::ImageDataParameter* release_image_data_param(); + void set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param); + + // optional .caffe.InfogainLossParameter infogain_loss_param = 116; + bool has_infogain_loss_param() const; + void clear_infogain_loss_param(); + static const int kInfogainLossParamFieldNumber = 116; + const ::caffe::InfogainLossParameter& infogain_loss_param() const; + ::caffe::InfogainLossParameter* mutable_infogain_loss_param(); + ::caffe::InfogainLossParameter* release_infogain_loss_param(); + void set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param); + + // optional .caffe.InnerProductParameter inner_product_param = 117; + bool has_inner_product_param() const; + void clear_inner_product_param(); + static const int kInnerProductParamFieldNumber = 117; + const ::caffe::InnerProductParameter& inner_product_param() const; + ::caffe::InnerProductParameter* mutable_inner_product_param(); + ::caffe::InnerProductParameter* release_inner_product_param(); + void set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param); + + // optional .caffe.InputParameter input_param = 143; + bool has_input_param() const; + void clear_input_param(); + static const int kInputParamFieldNumber = 143; + const ::caffe::InputParameter& input_param() const; + ::caffe::InputParameter* mutable_input_param(); + ::caffe::InputParameter* release_input_param(); + void set_allocated_input_param(::caffe::InputParameter* input_param); + + // optional .caffe.LogParameter log_param = 134; + bool has_log_param() const; + void clear_log_param(); + static const int kLogParamFieldNumber = 134; + const ::caffe::LogParameter& log_param() const; + ::caffe::LogParameter* mutable_log_param(); + ::caffe::LogParameter* release_log_param(); + void set_allocated_log_param(::caffe::LogParameter* log_param); + + // optional .caffe.LRNParameter lrn_param = 118; + bool has_lrn_param() const; + void clear_lrn_param(); + static const int kLrnParamFieldNumber = 118; + const ::caffe::LRNParameter& lrn_param() const; + ::caffe::LRNParameter* mutable_lrn_param(); + ::caffe::LRNParameter* release_lrn_param(); + void set_allocated_lrn_param(::caffe::LRNParameter* lrn_param); + + // optional .caffe.MemoryDataParameter memory_data_param = 119; + bool has_memory_data_param() const; + void clear_memory_data_param(); + static const int kMemoryDataParamFieldNumber = 119; + const ::caffe::MemoryDataParameter& memory_data_param() const; + ::caffe::MemoryDataParameter* mutable_memory_data_param(); + ::caffe::MemoryDataParameter* release_memory_data_param(); + void set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param); + + // optional .caffe.MVNParameter mvn_param = 120; + bool has_mvn_param() const; + void clear_mvn_param(); + static const int kMvnParamFieldNumber = 120; + const ::caffe::MVNParameter& mvn_param() const; + ::caffe::MVNParameter* mutable_mvn_param(); + ::caffe::MVNParameter* release_mvn_param(); + void set_allocated_mvn_param(::caffe::MVNParameter* mvn_param); + + // optional .caffe.NormalizeBBoxParameter norm_param = 149; + bool has_norm_param() const; + void clear_norm_param(); + static const int kNormParamFieldNumber = 149; + const ::caffe::NormalizeBBoxParameter& norm_param() const; + ::caffe::NormalizeBBoxParameter* mutable_norm_param(); + ::caffe::NormalizeBBoxParameter* release_norm_param(); + void set_allocated_norm_param(::caffe::NormalizeBBoxParameter* norm_param); + + // optional .caffe.PermuteParameter permute_param = 148; + bool has_permute_param() const; + void clear_permute_param(); + static const int kPermuteParamFieldNumber = 148; + const ::caffe::PermuteParameter& permute_param() const; + ::caffe::PermuteParameter* mutable_permute_param(); + ::caffe::PermuteParameter* release_permute_param(); + void set_allocated_permute_param(::caffe::PermuteParameter* permute_param); + + // optional .caffe.ParameterParameter parameter_param = 145; + bool has_parameter_param() const; + void clear_parameter_param(); + static const int kParameterParamFieldNumber = 145; + const ::caffe::ParameterParameter& parameter_param() const; + ::caffe::ParameterParameter* mutable_parameter_param(); + ::caffe::ParameterParameter* release_parameter_param(); + void set_allocated_parameter_param(::caffe::ParameterParameter* parameter_param); + + // optional .caffe.PoolingParameter pooling_param = 121; + bool has_pooling_param() const; + void clear_pooling_param(); + static const int kPoolingParamFieldNumber = 121; + const ::caffe::PoolingParameter& pooling_param() const; + ::caffe::PoolingParameter* mutable_pooling_param(); + ::caffe::PoolingParameter* release_pooling_param(); + void set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param); + + // optional .caffe.PowerParameter power_param = 122; + bool has_power_param() const; + void clear_power_param(); + static const int kPowerParamFieldNumber = 122; + const ::caffe::PowerParameter& power_param() const; + ::caffe::PowerParameter* mutable_power_param(); + ::caffe::PowerParameter* release_power_param(); + void set_allocated_power_param(::caffe::PowerParameter* power_param); + + // optional .caffe.PReLUParameter prelu_param = 131; + bool has_prelu_param() const; + void clear_prelu_param(); + static const int kPreluParamFieldNumber = 131; + const ::caffe::PReLUParameter& prelu_param() const; + ::caffe::PReLUParameter* mutable_prelu_param(); + ::caffe::PReLUParameter* release_prelu_param(); + void set_allocated_prelu_param(::caffe::PReLUParameter* prelu_param); + + // optional .caffe.PriorBoxParameter prior_box_param = 150; + bool has_prior_box_param() const; + void clear_prior_box_param(); + static const int kPriorBoxParamFieldNumber = 150; + const ::caffe::PriorBoxParameter& prior_box_param() const; + ::caffe::PriorBoxParameter* mutable_prior_box_param(); + ::caffe::PriorBoxParameter* release_prior_box_param(); + void set_allocated_prior_box_param(::caffe::PriorBoxParameter* prior_box_param); + + // optional .caffe.PythonParameter python_param = 130; + bool has_python_param() const; + void clear_python_param(); + static const int kPythonParamFieldNumber = 130; + const ::caffe::PythonParameter& python_param() const; + ::caffe::PythonParameter* mutable_python_param(); + ::caffe::PythonParameter* release_python_param(); + void set_allocated_python_param(::caffe::PythonParameter* python_param); + + // optional .caffe.RecurrentParameter recurrent_param = 146; + bool has_recurrent_param() const; + void clear_recurrent_param(); + static const int kRecurrentParamFieldNumber = 146; + const ::caffe::RecurrentParameter& recurrent_param() const; + ::caffe::RecurrentParameter* mutable_recurrent_param(); + ::caffe::RecurrentParameter* release_recurrent_param(); + void set_allocated_recurrent_param(::caffe::RecurrentParameter* recurrent_param); + + // optional .caffe.ReductionParameter reduction_param = 136; + bool has_reduction_param() const; + void clear_reduction_param(); + static const int kReductionParamFieldNumber = 136; + const ::caffe::ReductionParameter& reduction_param() const; + ::caffe::ReductionParameter* mutable_reduction_param(); + ::caffe::ReductionParameter* release_reduction_param(); + void set_allocated_reduction_param(::caffe::ReductionParameter* reduction_param); + + // optional .caffe.ReLUParameter relu_param = 123; + bool has_relu_param() const; + void clear_relu_param(); + static const int kReluParamFieldNumber = 123; + const ::caffe::ReLUParameter& relu_param() const; + ::caffe::ReLUParameter* mutable_relu_param(); + ::caffe::ReLUParameter* release_relu_param(); + void set_allocated_relu_param(::caffe::ReLUParameter* relu_param); + + // optional .caffe.ReshapeParameter reshape_param = 133; + bool has_reshape_param() const; + void clear_reshape_param(); + static const int kReshapeParamFieldNumber = 133; + const ::caffe::ReshapeParameter& reshape_param() const; + ::caffe::ReshapeParameter* mutable_reshape_param(); + ::caffe::ReshapeParameter* release_reshape_param(); + void set_allocated_reshape_param(::caffe::ReshapeParameter* reshape_param); + + // optional .caffe.ScaleParameter scale_param = 142; + bool has_scale_param() const; + void clear_scale_param(); + static const int kScaleParamFieldNumber = 142; + const ::caffe::ScaleParameter& scale_param() const; + ::caffe::ScaleParameter* mutable_scale_param(); + ::caffe::ScaleParameter* release_scale_param(); + void set_allocated_scale_param(::caffe::ScaleParameter* scale_param); + + // optional .caffe.SigmoidParameter sigmoid_param = 124; + bool has_sigmoid_param() const; + void clear_sigmoid_param(); + static const int kSigmoidParamFieldNumber = 124; + const ::caffe::SigmoidParameter& sigmoid_param() const; + ::caffe::SigmoidParameter* mutable_sigmoid_param(); + ::caffe::SigmoidParameter* release_sigmoid_param(); + void set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param); + + // optional .caffe.SoftmaxParameter softmax_param = 125; + bool has_softmax_param() const; + void clear_softmax_param(); + static const int kSoftmaxParamFieldNumber = 125; + const ::caffe::SoftmaxParameter& softmax_param() const; + ::caffe::SoftmaxParameter* mutable_softmax_param(); + ::caffe::SoftmaxParameter* release_softmax_param(); + void set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param); + + // optional .caffe.SPPParameter spp_param = 132; + bool has_spp_param() const; + void clear_spp_param(); + static const int kSppParamFieldNumber = 132; + const ::caffe::SPPParameter& spp_param() const; + ::caffe::SPPParameter* mutable_spp_param(); + ::caffe::SPPParameter* release_spp_param(); + void set_allocated_spp_param(::caffe::SPPParameter* spp_param); + + // optional .caffe.SliceParameter slice_param = 126; + bool has_slice_param() const; + void clear_slice_param(); + static const int kSliceParamFieldNumber = 126; + const ::caffe::SliceParameter& slice_param() const; + ::caffe::SliceParameter* mutable_slice_param(); + ::caffe::SliceParameter* release_slice_param(); + void set_allocated_slice_param(::caffe::SliceParameter* slice_param); + + // optional .caffe.TanHParameter tanh_param = 127; + bool has_tanh_param() const; + void clear_tanh_param(); + static const int kTanhParamFieldNumber = 127; + const ::caffe::TanHParameter& tanh_param() const; + ::caffe::TanHParameter* mutable_tanh_param(); + ::caffe::TanHParameter* release_tanh_param(); + void set_allocated_tanh_param(::caffe::TanHParameter* tanh_param); + + // optional .caffe.ThresholdParameter threshold_param = 128; + bool has_threshold_param() const; + void clear_threshold_param(); + static const int kThresholdParamFieldNumber = 128; + const ::caffe::ThresholdParameter& threshold_param() const; + ::caffe::ThresholdParameter* mutable_threshold_param(); + ::caffe::ThresholdParameter* release_threshold_param(); + void set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param); + + // optional .caffe.TileParameter tile_param = 138; + bool has_tile_param() const; + void clear_tile_param(); + static const int kTileParamFieldNumber = 138; + const ::caffe::TileParameter& tile_param() const; + ::caffe::TileParameter* mutable_tile_param(); + ::caffe::TileParameter* release_tile_param(); + void set_allocated_tile_param(::caffe::TileParameter* tile_param); + + // optional .caffe.WindowDataParameter window_data_param = 129; + bool has_window_data_param() const; + void clear_window_data_param(); + static const int kWindowDataParamFieldNumber = 129; + const ::caffe::WindowDataParameter& window_data_param() const; + ::caffe::WindowDataParameter* mutable_window_data_param(); + ::caffe::WindowDataParameter* release_window_data_param(); + void set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param); + + // @@protoc_insertion_point(class_scope:caffe.LayerParameter) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_phase(); + inline void clear_has_phase(); + inline void set_has_transform_param(); + inline void clear_has_transform_param(); + inline void set_has_loss_param(); + inline void clear_has_loss_param(); + inline void set_has_accuracy_param(); + inline void clear_has_accuracy_param(); + inline void set_has_argmax_param(); + inline void clear_has_argmax_param(); + inline void set_has_batch_norm_param(); + inline void clear_has_batch_norm_param(); + inline void set_has_bias_param(); + inline void clear_has_bias_param(); + inline void set_has_concat_param(); + inline void clear_has_concat_param(); + inline void set_has_contrastive_loss_param(); + inline void clear_has_contrastive_loss_param(); + inline void set_has_convolution_param(); + inline void clear_has_convolution_param(); + inline void set_has_crop_param(); + inline void clear_has_crop_param(); + inline void set_has_data_param(); + inline void clear_has_data_param(); + inline void set_has_detection_output_param(); + inline void clear_has_detection_output_param(); + inline void set_has_dropout_param(); + inline void clear_has_dropout_param(); + inline void set_has_dummy_data_param(); + inline void clear_has_dummy_data_param(); + inline void set_has_eltwise_param(); + inline void clear_has_eltwise_param(); + inline void set_has_elu_param(); + inline void clear_has_elu_param(); + inline void set_has_embed_param(); + inline void clear_has_embed_param(); + inline void set_has_exp_param(); + inline void clear_has_exp_param(); + inline void set_has_flatten_param(); + inline void clear_has_flatten_param(); + inline void set_has_hdf5_data_param(); + inline void clear_has_hdf5_data_param(); + inline void set_has_hdf5_output_param(); + inline void clear_has_hdf5_output_param(); + inline void set_has_hinge_loss_param(); + inline void clear_has_hinge_loss_param(); + inline void set_has_image_data_param(); + inline void clear_has_image_data_param(); + inline void set_has_infogain_loss_param(); + inline void clear_has_infogain_loss_param(); + inline void set_has_inner_product_param(); + inline void clear_has_inner_product_param(); + inline void set_has_input_param(); + inline void clear_has_input_param(); + inline void set_has_log_param(); + inline void clear_has_log_param(); + inline void set_has_lrn_param(); + inline void clear_has_lrn_param(); + inline void set_has_memory_data_param(); + inline void clear_has_memory_data_param(); + inline void set_has_mvn_param(); + inline void clear_has_mvn_param(); + inline void set_has_norm_param(); + inline void clear_has_norm_param(); + inline void set_has_permute_param(); + inline void clear_has_permute_param(); + inline void set_has_parameter_param(); + inline void clear_has_parameter_param(); + inline void set_has_pooling_param(); + inline void clear_has_pooling_param(); + inline void set_has_power_param(); + inline void clear_has_power_param(); + inline void set_has_prelu_param(); + inline void clear_has_prelu_param(); + inline void set_has_prior_box_param(); + inline void clear_has_prior_box_param(); + inline void set_has_python_param(); + inline void clear_has_python_param(); + inline void set_has_recurrent_param(); + inline void clear_has_recurrent_param(); + inline void set_has_reduction_param(); + inline void clear_has_reduction_param(); + inline void set_has_relu_param(); + inline void clear_has_relu_param(); + inline void set_has_reshape_param(); + inline void clear_has_reshape_param(); + inline void set_has_scale_param(); + inline void clear_has_scale_param(); + inline void set_has_sigmoid_param(); + inline void clear_has_sigmoid_param(); + inline void set_has_softmax_param(); + inline void clear_has_softmax_param(); + inline void set_has_spp_param(); + inline void clear_has_spp_param(); + inline void set_has_slice_param(); + inline void clear_has_slice_param(); + inline void set_has_tanh_param(); + inline void clear_has_tanh_param(); + inline void set_has_threshold_param(); + inline void clear_has_threshold_param(); + inline void set_has_tile_param(); + inline void clear_has_tile_param(); + inline void set_has_window_data_param(); + inline void clear_has_window_data_param(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<2> _has_bits_; + ::google::protobuf::RepeatedPtrField< ::std::string> bottom_; + ::google::protobuf::RepeatedPtrField< ::std::string> top_; + ::google::protobuf::RepeatedField< float > loss_weight_; + ::google::protobuf::RepeatedPtrField< ::caffe::ParamSpec > param_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > blobs_; + ::google::protobuf::RepeatedField< bool > propagate_down_; + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule > include_; + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule > exclude_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::caffe::TransformationParameter* transform_param_; + ::caffe::LossParameter* loss_param_; + ::caffe::AccuracyParameter* accuracy_param_; + ::caffe::ArgMaxParameter* argmax_param_; + ::caffe::BatchNormParameter* batch_norm_param_; + ::caffe::BiasParameter* bias_param_; + ::caffe::ConcatParameter* concat_param_; + ::caffe::ContrastiveLossParameter* contrastive_loss_param_; + ::caffe::ConvolutionParameter* convolution_param_; + ::caffe::CropParameter* crop_param_; + ::caffe::DataParameter* data_param_; + ::caffe::DetectionOutputParameter* detection_output_param_; + ::caffe::DropoutParameter* dropout_param_; + ::caffe::DummyDataParameter* dummy_data_param_; + ::caffe::EltwiseParameter* eltwise_param_; + ::caffe::ELUParameter* elu_param_; + ::caffe::EmbedParameter* embed_param_; + ::caffe::ExpParameter* exp_param_; + ::caffe::FlattenParameter* flatten_param_; + ::caffe::HDF5DataParameter* hdf5_data_param_; + ::caffe::HDF5OutputParameter* hdf5_output_param_; + ::caffe::HingeLossParameter* hinge_loss_param_; + ::caffe::ImageDataParameter* image_data_param_; + ::caffe::InfogainLossParameter* infogain_loss_param_; + ::caffe::InnerProductParameter* inner_product_param_; + ::caffe::InputParameter* input_param_; + ::caffe::LogParameter* log_param_; + ::caffe::LRNParameter* lrn_param_; + ::caffe::MemoryDataParameter* memory_data_param_; + ::caffe::MVNParameter* mvn_param_; + ::caffe::NormalizeBBoxParameter* norm_param_; + ::caffe::PermuteParameter* permute_param_; + ::caffe::ParameterParameter* parameter_param_; + ::caffe::PoolingParameter* pooling_param_; + ::caffe::PowerParameter* power_param_; + ::caffe::PReLUParameter* prelu_param_; + ::caffe::PriorBoxParameter* prior_box_param_; + ::caffe::PythonParameter* python_param_; + ::caffe::RecurrentParameter* recurrent_param_; + ::caffe::ReductionParameter* reduction_param_; + ::caffe::ReLUParameter* relu_param_; + ::caffe::ReshapeParameter* reshape_param_; + ::caffe::ScaleParameter* scale_param_; + ::caffe::SigmoidParameter* sigmoid_param_; + ::caffe::SoftmaxParameter* softmax_param_; + ::caffe::SPPParameter* spp_param_; + ::caffe::SliceParameter* slice_param_; + ::caffe::TanHParameter* tanh_param_; + ::caffe::ThresholdParameter* threshold_param_; + ::caffe::TileParameter* tile_param_; + ::caffe::WindowDataParameter* window_data_param_; + int phase_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed LayerParameter_default_instance_; + +// ------------------------------------------------------------------- + +class TransformationParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.TransformationParameter) */ { + public: + TransformationParameter(); + virtual ~TransformationParameter(); + + TransformationParameter(const TransformationParameter& from); + + inline TransformationParameter& operator=(const TransformationParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const TransformationParameter& default_instance(); + + static const TransformationParameter* internal_default_instance(); + + void Swap(TransformationParameter* other); + + // implements Message ---------------------------------------------- + + inline TransformationParameter* New() const { return New(NULL); } + + TransformationParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TransformationParameter& from); + void MergeFrom(const TransformationParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TransformationParameter* other); + void UnsafeMergeFrom(const TransformationParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float scale = 1 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 1; + float scale() const; + void set_scale(float value); + + // optional bool mirror = 2 [default = false]; + bool has_mirror() const; + void clear_mirror(); + static const int kMirrorFieldNumber = 2; + bool mirror() const; + void set_mirror(bool value); + + // optional uint32 crop_size = 3 [default = 0]; + bool has_crop_size() const; + void clear_crop_size(); + static const int kCropSizeFieldNumber = 3; + ::google::protobuf::uint32 crop_size() const; + void set_crop_size(::google::protobuf::uint32 value); + + // optional string mean_file = 4; + bool has_mean_file() const; + void clear_mean_file(); + static const int kMeanFileFieldNumber = 4; + const ::std::string& mean_file() const; + void set_mean_file(const ::std::string& value); + void set_mean_file(const char* value); + void set_mean_file(const char* value, size_t size); + ::std::string* mutable_mean_file(); + ::std::string* release_mean_file(); + void set_allocated_mean_file(::std::string* mean_file); + + // repeated float mean_value = 5; + int mean_value_size() const; + void clear_mean_value(); + static const int kMeanValueFieldNumber = 5; + float mean_value(int index) const; + void set_mean_value(int index, float value); + void add_mean_value(float value); + const ::google::protobuf::RepeatedField< float >& + mean_value() const; + ::google::protobuf::RepeatedField< float >* + mutable_mean_value(); + + // optional bool force_color = 6 [default = false]; + bool has_force_color() const; + void clear_force_color(); + static const int kForceColorFieldNumber = 6; + bool force_color() const; + void set_force_color(bool value); + + // optional bool force_gray = 7 [default = false]; + bool has_force_gray() const; + void clear_force_gray(); + static const int kForceGrayFieldNumber = 7; + bool force_gray() const; + void set_force_gray(bool value); + + // @@protoc_insertion_point(class_scope:caffe.TransformationParameter) + private: + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_mirror(); + inline void clear_has_mirror(); + inline void set_has_crop_size(); + inline void clear_has_crop_size(); + inline void set_has_mean_file(); + inline void clear_has_mean_file(); + inline void set_has_force_color(); + inline void clear_has_force_color(); + inline void set_has_force_gray(); + inline void clear_has_force_gray(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< float > mean_value_; + ::google::protobuf::internal::ArenaStringPtr mean_file_; + ::google::protobuf::uint32 crop_size_; + bool mirror_; + bool force_color_; + bool force_gray_; + float scale_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed TransformationParameter_default_instance_; + +// ------------------------------------------------------------------- + +class LossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.LossParameter) */ { + public: + LossParameter(); + virtual ~LossParameter(); + + LossParameter(const LossParameter& from); + + inline LossParameter& operator=(const LossParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LossParameter& default_instance(); + + static const LossParameter* internal_default_instance(); + + void Swap(LossParameter* other); + + // implements Message ---------------------------------------------- + + inline LossParameter* New() const { return New(NULL); } + + LossParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LossParameter& from); + void MergeFrom(const LossParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LossParameter* other); + void UnsafeMergeFrom(const LossParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef LossParameter_NormalizationMode NormalizationMode; + static const NormalizationMode FULL = + LossParameter_NormalizationMode_FULL; + static const NormalizationMode VALID = + LossParameter_NormalizationMode_VALID; + static const NormalizationMode BATCH_SIZE = + LossParameter_NormalizationMode_BATCH_SIZE; + static const NormalizationMode NONE = + LossParameter_NormalizationMode_NONE; + static inline bool NormalizationMode_IsValid(int value) { + return LossParameter_NormalizationMode_IsValid(value); + } + static const NormalizationMode NormalizationMode_MIN = + LossParameter_NormalizationMode_NormalizationMode_MIN; + static const NormalizationMode NormalizationMode_MAX = + LossParameter_NormalizationMode_NormalizationMode_MAX; + static const int NormalizationMode_ARRAYSIZE = + LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + NormalizationMode_descriptor() { + return LossParameter_NormalizationMode_descriptor(); + } + static inline const ::std::string& NormalizationMode_Name(NormalizationMode value) { + return LossParameter_NormalizationMode_Name(value); + } + static inline bool NormalizationMode_Parse(const ::std::string& name, + NormalizationMode* value) { + return LossParameter_NormalizationMode_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional int32 ignore_label = 1; + bool has_ignore_label() const; + void clear_ignore_label(); + static const int kIgnoreLabelFieldNumber = 1; + ::google::protobuf::int32 ignore_label() const; + void set_ignore_label(::google::protobuf::int32 value); + + // optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; + bool has_normalization() const; + void clear_normalization(); + static const int kNormalizationFieldNumber = 3; + ::caffe::LossParameter_NormalizationMode normalization() const; + void set_normalization(::caffe::LossParameter_NormalizationMode value); + + // optional bool normalize = 2; + bool has_normalize() const; + void clear_normalize(); + static const int kNormalizeFieldNumber = 2; + bool normalize() const; + void set_normalize(bool value); + + // @@protoc_insertion_point(class_scope:caffe.LossParameter) + private: + inline void set_has_ignore_label(); + inline void clear_has_ignore_label(); + inline void set_has_normalization(); + inline void clear_has_normalization(); + inline void set_has_normalize(); + inline void clear_has_normalize(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::int32 ignore_label_; + bool normalize_; + int normalization_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed LossParameter_default_instance_; + +// ------------------------------------------------------------------- + +class AccuracyParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.AccuracyParameter) */ { + public: + AccuracyParameter(); + virtual ~AccuracyParameter(); + + AccuracyParameter(const AccuracyParameter& from); + + inline AccuracyParameter& operator=(const AccuracyParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccuracyParameter& default_instance(); + + static const AccuracyParameter* internal_default_instance(); + + void Swap(AccuracyParameter* other); + + // implements Message ---------------------------------------------- + + inline AccuracyParameter* New() const { return New(NULL); } + + AccuracyParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccuracyParameter& from); + void MergeFrom(const AccuracyParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(AccuracyParameter* other); + void UnsafeMergeFrom(const AccuracyParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 top_k = 1 [default = 1]; + bool has_top_k() const; + void clear_top_k(); + static const int kTopKFieldNumber = 1; + ::google::protobuf::uint32 top_k() const; + void set_top_k(::google::protobuf::uint32 value); + + // optional int32 axis = 2 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 2; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional int32 ignore_label = 3; + bool has_ignore_label() const; + void clear_ignore_label(); + static const int kIgnoreLabelFieldNumber = 3; + ::google::protobuf::int32 ignore_label() const; + void set_ignore_label(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.AccuracyParameter) + private: + inline void set_has_top_k(); + inline void clear_has_top_k(); + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_ignore_label(); + inline void clear_has_ignore_label(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::int32 ignore_label_; + ::google::protobuf::uint32 top_k_; + ::google::protobuf::int32 axis_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed AccuracyParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ArgMaxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ArgMaxParameter) */ { + public: + ArgMaxParameter(); + virtual ~ArgMaxParameter(); + + ArgMaxParameter(const ArgMaxParameter& from); + + inline ArgMaxParameter& operator=(const ArgMaxParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ArgMaxParameter& default_instance(); + + static const ArgMaxParameter* internal_default_instance(); + + void Swap(ArgMaxParameter* other); + + // implements Message ---------------------------------------------- + + inline ArgMaxParameter* New() const { return New(NULL); } + + ArgMaxParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ArgMaxParameter& from); + void MergeFrom(const ArgMaxParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ArgMaxParameter* other); + void UnsafeMergeFrom(const ArgMaxParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool out_max_val = 1 [default = false]; + bool has_out_max_val() const; + void clear_out_max_val(); + static const int kOutMaxValFieldNumber = 1; + bool out_max_val() const; + void set_out_max_val(bool value); + + // optional uint32 top_k = 2 [default = 1]; + bool has_top_k() const; + void clear_top_k(); + static const int kTopKFieldNumber = 2; + ::google::protobuf::uint32 top_k() const; + void set_top_k(::google::protobuf::uint32 value); + + // optional int32 axis = 3; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 3; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.ArgMaxParameter) + private: + inline void set_has_out_max_val(); + inline void clear_has_out_max_val(); + inline void set_has_top_k(); + inline void clear_has_top_k(); + inline void set_has_axis(); + inline void clear_has_axis(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + bool out_max_val_; + ::google::protobuf::int32 axis_; + ::google::protobuf::uint32 top_k_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ArgMaxParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ConcatParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ConcatParameter) */ { + public: + ConcatParameter(); + virtual ~ConcatParameter(); + + ConcatParameter(const ConcatParameter& from); + + inline ConcatParameter& operator=(const ConcatParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ConcatParameter& default_instance(); + + static const ConcatParameter* internal_default_instance(); + + void Swap(ConcatParameter* other); + + // implements Message ---------------------------------------------- + + inline ConcatParameter* New() const { return New(NULL); } + + ConcatParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ConcatParameter& from); + void MergeFrom(const ConcatParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ConcatParameter* other); + void UnsafeMergeFrom(const ConcatParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 axis = 2 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 2; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional uint32 concat_dim = 1 [default = 1]; + bool has_concat_dim() const; + void clear_concat_dim(); + static const int kConcatDimFieldNumber = 1; + ::google::protobuf::uint32 concat_dim() const; + void set_concat_dim(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:caffe.ConcatParameter) + private: + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_concat_dim(); + inline void clear_has_concat_dim(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::int32 axis_; + ::google::protobuf::uint32 concat_dim_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ConcatParameter_default_instance_; + +// ------------------------------------------------------------------- + +class BatchNormParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.BatchNormParameter) */ { + public: + BatchNormParameter(); + virtual ~BatchNormParameter(); + + BatchNormParameter(const BatchNormParameter& from); + + inline BatchNormParameter& operator=(const BatchNormParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BatchNormParameter& default_instance(); + + static const BatchNormParameter* internal_default_instance(); + + void Swap(BatchNormParameter* other); + + // implements Message ---------------------------------------------- + + inline BatchNormParameter* New() const { return New(NULL); } + + BatchNormParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BatchNormParameter& from); + void MergeFrom(const BatchNormParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BatchNormParameter* other); + void UnsafeMergeFrom(const BatchNormParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool use_global_stats = 1; + bool has_use_global_stats() const; + void clear_use_global_stats(); + static const int kUseGlobalStatsFieldNumber = 1; + bool use_global_stats() const; + void set_use_global_stats(bool value); + + // optional float moving_average_fraction = 2 [default = 0.999]; + bool has_moving_average_fraction() const; + void clear_moving_average_fraction(); + static const int kMovingAverageFractionFieldNumber = 2; + float moving_average_fraction() const; + void set_moving_average_fraction(float value); + + // optional float eps = 3 [default = 1e-05]; + bool has_eps() const; + void clear_eps(); + static const int kEpsFieldNumber = 3; + float eps() const; + void set_eps(float value); + + // @@protoc_insertion_point(class_scope:caffe.BatchNormParameter) + private: + inline void set_has_use_global_stats(); + inline void clear_has_use_global_stats(); + inline void set_has_moving_average_fraction(); + inline void clear_has_moving_average_fraction(); + inline void set_has_eps(); + inline void clear_has_eps(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + bool use_global_stats_; + float moving_average_fraction_; + float eps_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed BatchNormParameter_default_instance_; + +// ------------------------------------------------------------------- + +class BiasParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.BiasParameter) */ { + public: + BiasParameter(); + virtual ~BiasParameter(); + + BiasParameter(const BiasParameter& from); + + inline BiasParameter& operator=(const BiasParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BiasParameter& default_instance(); + + static const BiasParameter* internal_default_instance(); + + void Swap(BiasParameter* other); + + // implements Message ---------------------------------------------- + + inline BiasParameter* New() const { return New(NULL); } + + BiasParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BiasParameter& from); + void MergeFrom(const BiasParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BiasParameter* other); + void UnsafeMergeFrom(const BiasParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 1; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional int32 num_axes = 2 [default = 1]; + bool has_num_axes() const; + void clear_num_axes(); + static const int kNumAxesFieldNumber = 2; + ::google::protobuf::int32 num_axes() const; + void set_num_axes(::google::protobuf::int32 value); + + // optional .caffe.FillerParameter filler = 3; + bool has_filler() const; + void clear_filler(); + static const int kFillerFieldNumber = 3; + const ::caffe::FillerParameter& filler() const; + ::caffe::FillerParameter* mutable_filler(); + ::caffe::FillerParameter* release_filler(); + void set_allocated_filler(::caffe::FillerParameter* filler); + + // @@protoc_insertion_point(class_scope:caffe.BiasParameter) + private: + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_num_axes(); + inline void clear_has_num_axes(); + inline void set_has_filler(); + inline void clear_has_filler(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::FillerParameter* filler_; + ::google::protobuf::int32 axis_; + ::google::protobuf::int32 num_axes_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed BiasParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ContrastiveLossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ContrastiveLossParameter) */ { + public: + ContrastiveLossParameter(); + virtual ~ContrastiveLossParameter(); + + ContrastiveLossParameter(const ContrastiveLossParameter& from); + + inline ContrastiveLossParameter& operator=(const ContrastiveLossParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ContrastiveLossParameter& default_instance(); + + static const ContrastiveLossParameter* internal_default_instance(); + + void Swap(ContrastiveLossParameter* other); + + // implements Message ---------------------------------------------- + + inline ContrastiveLossParameter* New() const { return New(NULL); } + + ContrastiveLossParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ContrastiveLossParameter& from); + void MergeFrom(const ContrastiveLossParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ContrastiveLossParameter* other); + void UnsafeMergeFrom(const ContrastiveLossParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float margin = 1 [default = 1]; + bool has_margin() const; + void clear_margin(); + static const int kMarginFieldNumber = 1; + float margin() const; + void set_margin(float value); + + // optional bool legacy_version = 2 [default = false]; + bool has_legacy_version() const; + void clear_legacy_version(); + static const int kLegacyVersionFieldNumber = 2; + bool legacy_version() const; + void set_legacy_version(bool value); + + // @@protoc_insertion_point(class_scope:caffe.ContrastiveLossParameter) + private: + inline void set_has_margin(); + inline void clear_has_margin(); + inline void set_has_legacy_version(); + inline void clear_has_legacy_version(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + bool legacy_version_; + float margin_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ContrastiveLossParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ConvolutionParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ConvolutionParameter) */ { + public: + ConvolutionParameter(); + virtual ~ConvolutionParameter(); + + ConvolutionParameter(const ConvolutionParameter& from); + + inline ConvolutionParameter& operator=(const ConvolutionParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ConvolutionParameter& default_instance(); + + static const ConvolutionParameter* internal_default_instance(); + + void Swap(ConvolutionParameter* other); + + // implements Message ---------------------------------------------- + + inline ConvolutionParameter* New() const { return New(NULL); } + + ConvolutionParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ConvolutionParameter& from); + void MergeFrom(const ConvolutionParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ConvolutionParameter* other); + void UnsafeMergeFrom(const ConvolutionParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef ConvolutionParameter_Engine Engine; + static const Engine DEFAULT = + ConvolutionParameter_Engine_DEFAULT; + static const Engine CAFFE = + ConvolutionParameter_Engine_CAFFE; + static const Engine CUDNN = + ConvolutionParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return ConvolutionParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + ConvolutionParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + ConvolutionParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + ConvolutionParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return ConvolutionParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return ConvolutionParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return ConvolutionParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional uint32 num_output = 1; + bool has_num_output() const; + void clear_num_output(); + static const int kNumOutputFieldNumber = 1; + ::google::protobuf::uint32 num_output() const; + void set_num_output(::google::protobuf::uint32 value); + + // optional bool bias_term = 2 [default = true]; + bool has_bias_term() const; + void clear_bias_term(); + static const int kBiasTermFieldNumber = 2; + bool bias_term() const; + void set_bias_term(bool value); + + // repeated uint32 pad = 3; + int pad_size() const; + void clear_pad(); + static const int kPadFieldNumber = 3; + ::google::protobuf::uint32 pad(int index) const; + void set_pad(int index, ::google::protobuf::uint32 value); + void add_pad(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + pad() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_pad(); + + // repeated uint32 kernel_size = 4; + int kernel_size_size() const; + void clear_kernel_size(); + static const int kKernelSizeFieldNumber = 4; + ::google::protobuf::uint32 kernel_size(int index) const; + void set_kernel_size(int index, ::google::protobuf::uint32 value); + void add_kernel_size(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + kernel_size() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_kernel_size(); + + // repeated uint32 stride = 6; + int stride_size() const; + void clear_stride(); + static const int kStrideFieldNumber = 6; + ::google::protobuf::uint32 stride(int index) const; + void set_stride(int index, ::google::protobuf::uint32 value); + void add_stride(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + stride() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_stride(); + + // repeated uint32 dilation = 18; + int dilation_size() const; + void clear_dilation(); + static const int kDilationFieldNumber = 18; + ::google::protobuf::uint32 dilation(int index) const; + void set_dilation(int index, ::google::protobuf::uint32 value); + void add_dilation(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + dilation() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_dilation(); + + // optional uint32 pad_h = 9 [default = 0]; + bool has_pad_h() const; + void clear_pad_h(); + static const int kPadHFieldNumber = 9; + ::google::protobuf::uint32 pad_h() const; + void set_pad_h(::google::protobuf::uint32 value); + + // optional uint32 pad_w = 10 [default = 0]; + bool has_pad_w() const; + void clear_pad_w(); + static const int kPadWFieldNumber = 10; + ::google::protobuf::uint32 pad_w() const; + void set_pad_w(::google::protobuf::uint32 value); + + // optional uint32 kernel_h = 11; + bool has_kernel_h() const; + void clear_kernel_h(); + static const int kKernelHFieldNumber = 11; + ::google::protobuf::uint32 kernel_h() const; + void set_kernel_h(::google::protobuf::uint32 value); + + // optional uint32 kernel_w = 12; + bool has_kernel_w() const; + void clear_kernel_w(); + static const int kKernelWFieldNumber = 12; + ::google::protobuf::uint32 kernel_w() const; + void set_kernel_w(::google::protobuf::uint32 value); + + // optional uint32 stride_h = 13; + bool has_stride_h() const; + void clear_stride_h(); + static const int kStrideHFieldNumber = 13; + ::google::protobuf::uint32 stride_h() const; + void set_stride_h(::google::protobuf::uint32 value); + + // optional uint32 stride_w = 14; + bool has_stride_w() const; + void clear_stride_w(); + static const int kStrideWFieldNumber = 14; + ::google::protobuf::uint32 stride_w() const; + void set_stride_w(::google::protobuf::uint32 value); + + // optional uint32 group = 5 [default = 1]; + bool has_group() const; + void clear_group(); + static const int kGroupFieldNumber = 5; + ::google::protobuf::uint32 group() const; + void set_group(::google::protobuf::uint32 value); + + // optional .caffe.FillerParameter weight_filler = 7; + bool has_weight_filler() const; + void clear_weight_filler(); + static const int kWeightFillerFieldNumber = 7; + const ::caffe::FillerParameter& weight_filler() const; + ::caffe::FillerParameter* mutable_weight_filler(); + ::caffe::FillerParameter* release_weight_filler(); + void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler); + + // optional .caffe.FillerParameter bias_filler = 8; + bool has_bias_filler() const; + void clear_bias_filler(); + static const int kBiasFillerFieldNumber = 8; + const ::caffe::FillerParameter& bias_filler() const; + ::caffe::FillerParameter* mutable_bias_filler(); + ::caffe::FillerParameter* release_bias_filler(); + void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler); + + // optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 15; + ::caffe::ConvolutionParameter_Engine engine() const; + void set_engine(::caffe::ConvolutionParameter_Engine value); + + // optional int32 axis = 16 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 16; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional bool force_nd_im2col = 17 [default = false]; + bool has_force_nd_im2col() const; + void clear_force_nd_im2col(); + static const int kForceNdIm2ColFieldNumber = 17; + bool force_nd_im2col() const; + void set_force_nd_im2col(bool value); + + // @@protoc_insertion_point(class_scope:caffe.ConvolutionParameter) + private: + inline void set_has_num_output(); + inline void clear_has_num_output(); + inline void set_has_bias_term(); + inline void clear_has_bias_term(); + inline void set_has_pad_h(); + inline void clear_has_pad_h(); + inline void set_has_pad_w(); + inline void clear_has_pad_w(); + inline void set_has_kernel_h(); + inline void clear_has_kernel_h(); + inline void set_has_kernel_w(); + inline void clear_has_kernel_w(); + inline void set_has_stride_h(); + inline void clear_has_stride_h(); + inline void set_has_stride_w(); + inline void clear_has_stride_w(); + inline void set_has_group(); + inline void clear_has_group(); + inline void set_has_weight_filler(); + inline void clear_has_weight_filler(); + inline void set_has_bias_filler(); + inline void clear_has_bias_filler(); + inline void set_has_engine(); + inline void clear_has_engine(); + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_force_nd_im2col(); + inline void clear_has_force_nd_im2col(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > pad_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > kernel_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > stride_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > dilation_; + ::caffe::FillerParameter* weight_filler_; + ::caffe::FillerParameter* bias_filler_; + ::google::protobuf::uint32 num_output_; + ::google::protobuf::uint32 pad_h_; + ::google::protobuf::uint32 pad_w_; + ::google::protobuf::uint32 kernel_h_; + ::google::protobuf::uint32 kernel_w_; + ::google::protobuf::uint32 stride_h_; + ::google::protobuf::uint32 stride_w_; + int engine_; + bool force_nd_im2col_; + ::google::protobuf::int32 axis_; + bool bias_term_; + ::google::protobuf::uint32 group_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ConvolutionParameter_default_instance_; + +// ------------------------------------------------------------------- + +class CropParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.CropParameter) */ { + public: + CropParameter(); + virtual ~CropParameter(); + + CropParameter(const CropParameter& from); + + inline CropParameter& operator=(const CropParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CropParameter& default_instance(); + + static const CropParameter* internal_default_instance(); + + void Swap(CropParameter* other); + + // implements Message ---------------------------------------------- + + inline CropParameter* New() const { return New(NULL); } + + CropParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CropParameter& from); + void MergeFrom(const CropParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(CropParameter* other); + void UnsafeMergeFrom(const CropParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 axis = 1 [default = 2]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 1; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // repeated uint32 offset = 2; + int offset_size() const; + void clear_offset(); + static const int kOffsetFieldNumber = 2; + ::google::protobuf::uint32 offset(int index) const; + void set_offset(int index, ::google::protobuf::uint32 value); + void add_offset(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + offset() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_offset(); + + // @@protoc_insertion_point(class_scope:caffe.CropParameter) + private: + inline void set_has_axis(); + inline void clear_has_axis(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > offset_; + ::google::protobuf::int32 axis_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed CropParameter_default_instance_; + +// ------------------------------------------------------------------- + +class DataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.DataParameter) */ { + public: + DataParameter(); + virtual ~DataParameter(); + + DataParameter(const DataParameter& from); + + inline DataParameter& operator=(const DataParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DataParameter& default_instance(); + + static const DataParameter* internal_default_instance(); + + void Swap(DataParameter* other); + + // implements Message ---------------------------------------------- + + inline DataParameter* New() const { return New(NULL); } + + DataParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DataParameter& from); + void MergeFrom(const DataParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(DataParameter* other); + void UnsafeMergeFrom(const DataParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef DataParameter_DB DB; + static const DB LEVELDB = + DataParameter_DB_LEVELDB; + static const DB LMDB = + DataParameter_DB_LMDB; + static inline bool DB_IsValid(int value) { + return DataParameter_DB_IsValid(value); + } + static const DB DB_MIN = + DataParameter_DB_DB_MIN; + static const DB DB_MAX = + DataParameter_DB_DB_MAX; + static const int DB_ARRAYSIZE = + DataParameter_DB_DB_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + DB_descriptor() { + return DataParameter_DB_descriptor(); + } + static inline const ::std::string& DB_Name(DB value) { + return DataParameter_DB_Name(value); + } + static inline bool DB_Parse(const ::std::string& name, + DB* value) { + return DataParameter_DB_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional string source = 1; + bool has_source() const; + void clear_source(); + static const int kSourceFieldNumber = 1; + const ::std::string& source() const; + void set_source(const ::std::string& value); + void set_source(const char* value); + void set_source(const char* value, size_t size); + ::std::string* mutable_source(); + ::std::string* release_source(); + void set_allocated_source(::std::string* source); + + // optional uint32 batch_size = 4; + bool has_batch_size() const; + void clear_batch_size(); + static const int kBatchSizeFieldNumber = 4; + ::google::protobuf::uint32 batch_size() const; + void set_batch_size(::google::protobuf::uint32 value); + + // optional uint32 rand_skip = 7 [default = 0]; + bool has_rand_skip() const; + void clear_rand_skip(); + static const int kRandSkipFieldNumber = 7; + ::google::protobuf::uint32 rand_skip() const; + void set_rand_skip(::google::protobuf::uint32 value); + + // optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB]; + bool has_backend() const; + void clear_backend(); + static const int kBackendFieldNumber = 8; + ::caffe::DataParameter_DB backend() const; + void set_backend(::caffe::DataParameter_DB value); + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 2; + float scale() const; + void set_scale(float value); + + // optional string mean_file = 3; + bool has_mean_file() const; + void clear_mean_file(); + static const int kMeanFileFieldNumber = 3; + const ::std::string& mean_file() const; + void set_mean_file(const ::std::string& value); + void set_mean_file(const char* value); + void set_mean_file(const char* value, size_t size); + ::std::string* mutable_mean_file(); + ::std::string* release_mean_file(); + void set_allocated_mean_file(::std::string* mean_file); + + // optional uint32 crop_size = 5 [default = 0]; + bool has_crop_size() const; + void clear_crop_size(); + static const int kCropSizeFieldNumber = 5; + ::google::protobuf::uint32 crop_size() const; + void set_crop_size(::google::protobuf::uint32 value); + + // optional bool mirror = 6 [default = false]; + bool has_mirror() const; + void clear_mirror(); + static const int kMirrorFieldNumber = 6; + bool mirror() const; + void set_mirror(bool value); + + // optional bool force_encoded_color = 9 [default = false]; + bool has_force_encoded_color() const; + void clear_force_encoded_color(); + static const int kForceEncodedColorFieldNumber = 9; + bool force_encoded_color() const; + void set_force_encoded_color(bool value); + + // optional uint32 prefetch = 10 [default = 4]; + bool has_prefetch() const; + void clear_prefetch(); + static const int kPrefetchFieldNumber = 10; + ::google::protobuf::uint32 prefetch() const; + void set_prefetch(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:caffe.DataParameter) + private: + inline void set_has_source(); + inline void clear_has_source(); + inline void set_has_batch_size(); + inline void clear_has_batch_size(); + inline void set_has_rand_skip(); + inline void clear_has_rand_skip(); + inline void set_has_backend(); + inline void clear_has_backend(); + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_mean_file(); + inline void clear_has_mean_file(); + inline void set_has_crop_size(); + inline void clear_has_crop_size(); + inline void set_has_mirror(); + inline void clear_has_mirror(); + inline void set_has_force_encoded_color(); + inline void clear_has_force_encoded_color(); + inline void set_has_prefetch(); + inline void clear_has_prefetch(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr source_; + ::google::protobuf::internal::ArenaStringPtr mean_file_; + ::google::protobuf::uint32 batch_size_; + ::google::protobuf::uint32 rand_skip_; + int backend_; + ::google::protobuf::uint32 crop_size_; + bool mirror_; + bool force_encoded_color_; + float scale_; + ::google::protobuf::uint32 prefetch_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed DataParameter_default_instance_; + +// ------------------------------------------------------------------- + +class NonMaximumSuppressionParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.NonMaximumSuppressionParameter) */ { + public: + NonMaximumSuppressionParameter(); + virtual ~NonMaximumSuppressionParameter(); + + NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from); + + inline NonMaximumSuppressionParameter& operator=(const NonMaximumSuppressionParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NonMaximumSuppressionParameter& default_instance(); + + static const NonMaximumSuppressionParameter* internal_default_instance(); + + void Swap(NonMaximumSuppressionParameter* other); + + // implements Message ---------------------------------------------- + + inline NonMaximumSuppressionParameter* New() const { return New(NULL); } + + NonMaximumSuppressionParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NonMaximumSuppressionParameter& from); + void MergeFrom(const NonMaximumSuppressionParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NonMaximumSuppressionParameter* other); + void UnsafeMergeFrom(const NonMaximumSuppressionParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float nms_threshold = 1 [default = 0.3]; + bool has_nms_threshold() const; + void clear_nms_threshold(); + static const int kNmsThresholdFieldNumber = 1; + float nms_threshold() const; + void set_nms_threshold(float value); + + // optional int32 top_k = 2; + bool has_top_k() const; + void clear_top_k(); + static const int kTopKFieldNumber = 2; + ::google::protobuf::int32 top_k() const; + void set_top_k(::google::protobuf::int32 value); + + // optional float eta = 3 [default = 1]; + bool has_eta() const; + void clear_eta(); + static const int kEtaFieldNumber = 3; + float eta() const; + void set_eta(float value); + + // @@protoc_insertion_point(class_scope:caffe.NonMaximumSuppressionParameter) + private: + inline void set_has_nms_threshold(); + inline void clear_has_nms_threshold(); + inline void set_has_top_k(); + inline void clear_has_top_k(); + inline void set_has_eta(); + inline void clear_has_eta(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::int32 top_k_; + float nms_threshold_; + float eta_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NonMaximumSuppressionParameter_default_instance_; + +// ------------------------------------------------------------------- + +class SaveOutputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.SaveOutputParameter) */ { + public: + SaveOutputParameter(); + virtual ~SaveOutputParameter(); + + SaveOutputParameter(const SaveOutputParameter& from); + + inline SaveOutputParameter& operator=(const SaveOutputParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SaveOutputParameter& default_instance(); + + static const SaveOutputParameter* internal_default_instance(); + + void Swap(SaveOutputParameter* other); + + // implements Message ---------------------------------------------- + + inline SaveOutputParameter* New() const { return New(NULL); } + + SaveOutputParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SaveOutputParameter& from); + void MergeFrom(const SaveOutputParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SaveOutputParameter* other); + void UnsafeMergeFrom(const SaveOutputParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string output_directory = 1; + bool has_output_directory() const; + void clear_output_directory(); + static const int kOutputDirectoryFieldNumber = 1; + const ::std::string& output_directory() const; + void set_output_directory(const ::std::string& value); + void set_output_directory(const char* value); + void set_output_directory(const char* value, size_t size); + ::std::string* mutable_output_directory(); + ::std::string* release_output_directory(); + void set_allocated_output_directory(::std::string* output_directory); + + // optional string output_name_prefix = 2; + bool has_output_name_prefix() const; + void clear_output_name_prefix(); + static const int kOutputNamePrefixFieldNumber = 2; + const ::std::string& output_name_prefix() const; + void set_output_name_prefix(const ::std::string& value); + void set_output_name_prefix(const char* value); + void set_output_name_prefix(const char* value, size_t size); + ::std::string* mutable_output_name_prefix(); + ::std::string* release_output_name_prefix(); + void set_allocated_output_name_prefix(::std::string* output_name_prefix); + + // optional string output_format = 3; + bool has_output_format() const; + void clear_output_format(); + static const int kOutputFormatFieldNumber = 3; + const ::std::string& output_format() const; + void set_output_format(const ::std::string& value); + void set_output_format(const char* value); + void set_output_format(const char* value, size_t size); + ::std::string* mutable_output_format(); + ::std::string* release_output_format(); + void set_allocated_output_format(::std::string* output_format); + + // optional string label_map_file = 4; + bool has_label_map_file() const; + void clear_label_map_file(); + static const int kLabelMapFileFieldNumber = 4; + const ::std::string& label_map_file() const; + void set_label_map_file(const ::std::string& value); + void set_label_map_file(const char* value); + void set_label_map_file(const char* value, size_t size); + ::std::string* mutable_label_map_file(); + ::std::string* release_label_map_file(); + void set_allocated_label_map_file(::std::string* label_map_file); + + // optional string name_size_file = 5; + bool has_name_size_file() const; + void clear_name_size_file(); + static const int kNameSizeFileFieldNumber = 5; + const ::std::string& name_size_file() const; + void set_name_size_file(const ::std::string& value); + void set_name_size_file(const char* value); + void set_name_size_file(const char* value, size_t size); + ::std::string* mutable_name_size_file(); + ::std::string* release_name_size_file(); + void set_allocated_name_size_file(::std::string* name_size_file); + + // optional uint32 num_test_image = 6; + bool has_num_test_image() const; + void clear_num_test_image(); + static const int kNumTestImageFieldNumber = 6; + ::google::protobuf::uint32 num_test_image() const; + void set_num_test_image(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:caffe.SaveOutputParameter) + private: + inline void set_has_output_directory(); + inline void clear_has_output_directory(); + inline void set_has_output_name_prefix(); + inline void clear_has_output_name_prefix(); + inline void set_has_output_format(); + inline void clear_has_output_format(); + inline void set_has_label_map_file(); + inline void clear_has_label_map_file(); + inline void set_has_name_size_file(); + inline void clear_has_name_size_file(); + inline void set_has_num_test_image(); + inline void clear_has_num_test_image(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr output_directory_; + ::google::protobuf::internal::ArenaStringPtr output_name_prefix_; + ::google::protobuf::internal::ArenaStringPtr output_format_; + ::google::protobuf::internal::ArenaStringPtr label_map_file_; + ::google::protobuf::internal::ArenaStringPtr name_size_file_; + ::google::protobuf::uint32 num_test_image_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed SaveOutputParameter_default_instance_; + +// ------------------------------------------------------------------- + +class DropoutParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.DropoutParameter) */ { + public: + DropoutParameter(); + virtual ~DropoutParameter(); + + DropoutParameter(const DropoutParameter& from); + + inline DropoutParameter& operator=(const DropoutParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DropoutParameter& default_instance(); + + static const DropoutParameter* internal_default_instance(); + + void Swap(DropoutParameter* other); + + // implements Message ---------------------------------------------- + + inline DropoutParameter* New() const { return New(NULL); } + + DropoutParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DropoutParameter& from); + void MergeFrom(const DropoutParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(DropoutParameter* other); + void UnsafeMergeFrom(const DropoutParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float dropout_ratio = 1 [default = 0.5]; + bool has_dropout_ratio() const; + void clear_dropout_ratio(); + static const int kDropoutRatioFieldNumber = 1; + float dropout_ratio() const; + void set_dropout_ratio(float value); + + // @@protoc_insertion_point(class_scope:caffe.DropoutParameter) + private: + inline void set_has_dropout_ratio(); + inline void clear_has_dropout_ratio(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float dropout_ratio_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed DropoutParameter_default_instance_; + +// ------------------------------------------------------------------- + +class DummyDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.DummyDataParameter) */ { + public: + DummyDataParameter(); + virtual ~DummyDataParameter(); + + DummyDataParameter(const DummyDataParameter& from); + + inline DummyDataParameter& operator=(const DummyDataParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DummyDataParameter& default_instance(); + + static const DummyDataParameter* internal_default_instance(); + + void Swap(DummyDataParameter* other); + + // implements Message ---------------------------------------------- + + inline DummyDataParameter* New() const { return New(NULL); } + + DummyDataParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DummyDataParameter& from); + void MergeFrom(const DummyDataParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(DummyDataParameter* other); + void UnsafeMergeFrom(const DummyDataParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .caffe.FillerParameter data_filler = 1; + int data_filler_size() const; + void clear_data_filler(); + static const int kDataFillerFieldNumber = 1; + const ::caffe::FillerParameter& data_filler(int index) const; + ::caffe::FillerParameter* mutable_data_filler(int index); + ::caffe::FillerParameter* add_data_filler(); + ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >* + mutable_data_filler(); + const ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >& + data_filler() const; + + // repeated .caffe.BlobShape shape = 6; + int shape_size() const; + void clear_shape(); + static const int kShapeFieldNumber = 6; + const ::caffe::BlobShape& shape(int index) const; + ::caffe::BlobShape* mutable_shape(int index); + ::caffe::BlobShape* add_shape(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* + mutable_shape(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& + shape() const; + + // repeated uint32 num = 2; + int num_size() const; + void clear_num(); + static const int kNumFieldNumber = 2; + ::google::protobuf::uint32 num(int index) const; + void set_num(int index, ::google::protobuf::uint32 value); + void add_num(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + num() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_num(); + + // repeated uint32 channels = 3; + int channels_size() const; + void clear_channels(); + static const int kChannelsFieldNumber = 3; + ::google::protobuf::uint32 channels(int index) const; + void set_channels(int index, ::google::protobuf::uint32 value); + void add_channels(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + channels() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_channels(); + + // repeated uint32 height = 4; + int height_size() const; + void clear_height(); + static const int kHeightFieldNumber = 4; + ::google::protobuf::uint32 height(int index) const; + void set_height(int index, ::google::protobuf::uint32 value); + void add_height(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + height() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_height(); + + // repeated uint32 width = 5; + int width_size() const; + void clear_width(); + static const int kWidthFieldNumber = 5; + ::google::protobuf::uint32 width(int index) const; + void set_width(int index, ::google::protobuf::uint32 value); + void add_width(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + width() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_width(); + + // @@protoc_insertion_point(class_scope:caffe.DummyDataParameter) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter > data_filler_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape > shape_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > num_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > channels_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > height_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > width_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed DummyDataParameter_default_instance_; + +// ------------------------------------------------------------------- + +class EltwiseParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.EltwiseParameter) */ { + public: + EltwiseParameter(); + virtual ~EltwiseParameter(); + + EltwiseParameter(const EltwiseParameter& from); + + inline EltwiseParameter& operator=(const EltwiseParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const EltwiseParameter& default_instance(); + + static const EltwiseParameter* internal_default_instance(); + + void Swap(EltwiseParameter* other); + + // implements Message ---------------------------------------------- + + inline EltwiseParameter* New() const { return New(NULL); } + + EltwiseParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const EltwiseParameter& from); + void MergeFrom(const EltwiseParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(EltwiseParameter* other); + void UnsafeMergeFrom(const EltwiseParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef EltwiseParameter_EltwiseOp EltwiseOp; + static const EltwiseOp PROD = + EltwiseParameter_EltwiseOp_PROD; + static const EltwiseOp SUM = + EltwiseParameter_EltwiseOp_SUM; + static const EltwiseOp MAX = + EltwiseParameter_EltwiseOp_MAX; + static inline bool EltwiseOp_IsValid(int value) { + return EltwiseParameter_EltwiseOp_IsValid(value); + } + static const EltwiseOp EltwiseOp_MIN = + EltwiseParameter_EltwiseOp_EltwiseOp_MIN; + static const EltwiseOp EltwiseOp_MAX = + EltwiseParameter_EltwiseOp_EltwiseOp_MAX; + static const int EltwiseOp_ARRAYSIZE = + EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + EltwiseOp_descriptor() { + return EltwiseParameter_EltwiseOp_descriptor(); + } + static inline const ::std::string& EltwiseOp_Name(EltwiseOp value) { + return EltwiseParameter_EltwiseOp_Name(value); + } + static inline bool EltwiseOp_Parse(const ::std::string& name, + EltwiseOp* value) { + return EltwiseParameter_EltwiseOp_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; + bool has_operation() const; + void clear_operation(); + static const int kOperationFieldNumber = 1; + ::caffe::EltwiseParameter_EltwiseOp operation() const; + void set_operation(::caffe::EltwiseParameter_EltwiseOp value); + + // repeated float coeff = 2; + int coeff_size() const; + void clear_coeff(); + static const int kCoeffFieldNumber = 2; + float coeff(int index) const; + void set_coeff(int index, float value); + void add_coeff(float value); + const ::google::protobuf::RepeatedField< float >& + coeff() const; + ::google::protobuf::RepeatedField< float >* + mutable_coeff(); + + // optional bool stable_prod_grad = 3 [default = true]; + bool has_stable_prod_grad() const; + void clear_stable_prod_grad(); + static const int kStableProdGradFieldNumber = 3; + bool stable_prod_grad() const; + void set_stable_prod_grad(bool value); + + // @@protoc_insertion_point(class_scope:caffe.EltwiseParameter) + private: + inline void set_has_operation(); + inline void clear_has_operation(); + inline void set_has_stable_prod_grad(); + inline void clear_has_stable_prod_grad(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< float > coeff_; + int operation_; + bool stable_prod_grad_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed EltwiseParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ELUParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ELUParameter) */ { + public: + ELUParameter(); + virtual ~ELUParameter(); + + ELUParameter(const ELUParameter& from); + + inline ELUParameter& operator=(const ELUParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ELUParameter& default_instance(); + + static const ELUParameter* internal_default_instance(); + + void Swap(ELUParameter* other); + + // implements Message ---------------------------------------------- + + inline ELUParameter* New() const { return New(NULL); } + + ELUParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ELUParameter& from); + void MergeFrom(const ELUParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ELUParameter* other); + void UnsafeMergeFrom(const ELUParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float alpha = 1 [default = 1]; + bool has_alpha() const; + void clear_alpha(); + static const int kAlphaFieldNumber = 1; + float alpha() const; + void set_alpha(float value); + + // @@protoc_insertion_point(class_scope:caffe.ELUParameter) + private: + inline void set_has_alpha(); + inline void clear_has_alpha(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float alpha_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ELUParameter_default_instance_; + +// ------------------------------------------------------------------- + +class EmbedParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.EmbedParameter) */ { + public: + EmbedParameter(); + virtual ~EmbedParameter(); + + EmbedParameter(const EmbedParameter& from); + + inline EmbedParameter& operator=(const EmbedParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const EmbedParameter& default_instance(); + + static const EmbedParameter* internal_default_instance(); + + void Swap(EmbedParameter* other); + + // implements Message ---------------------------------------------- + + inline EmbedParameter* New() const { return New(NULL); } + + EmbedParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const EmbedParameter& from); + void MergeFrom(const EmbedParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(EmbedParameter* other); + void UnsafeMergeFrom(const EmbedParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 num_output = 1; + bool has_num_output() const; + void clear_num_output(); + static const int kNumOutputFieldNumber = 1; + ::google::protobuf::uint32 num_output() const; + void set_num_output(::google::protobuf::uint32 value); + + // optional uint32 input_dim = 2; + bool has_input_dim() const; + void clear_input_dim(); + static const int kInputDimFieldNumber = 2; + ::google::protobuf::uint32 input_dim() const; + void set_input_dim(::google::protobuf::uint32 value); + + // optional bool bias_term = 3 [default = true]; + bool has_bias_term() const; + void clear_bias_term(); + static const int kBiasTermFieldNumber = 3; + bool bias_term() const; + void set_bias_term(bool value); + + // optional .caffe.FillerParameter weight_filler = 4; + bool has_weight_filler() const; + void clear_weight_filler(); + static const int kWeightFillerFieldNumber = 4; + const ::caffe::FillerParameter& weight_filler() const; + ::caffe::FillerParameter* mutable_weight_filler(); + ::caffe::FillerParameter* release_weight_filler(); + void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler); + + // optional .caffe.FillerParameter bias_filler = 5; + bool has_bias_filler() const; + void clear_bias_filler(); + static const int kBiasFillerFieldNumber = 5; + const ::caffe::FillerParameter& bias_filler() const; + ::caffe::FillerParameter* mutable_bias_filler(); + ::caffe::FillerParameter* release_bias_filler(); + void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler); + + // @@protoc_insertion_point(class_scope:caffe.EmbedParameter) + private: + inline void set_has_num_output(); + inline void clear_has_num_output(); + inline void set_has_input_dim(); + inline void clear_has_input_dim(); + inline void set_has_bias_term(); + inline void clear_has_bias_term(); + inline void set_has_weight_filler(); + inline void clear_has_weight_filler(); + inline void set_has_bias_filler(); + inline void clear_has_bias_filler(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::FillerParameter* weight_filler_; + ::caffe::FillerParameter* bias_filler_; + ::google::protobuf::uint32 num_output_; + ::google::protobuf::uint32 input_dim_; + bool bias_term_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed EmbedParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ExpParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ExpParameter) */ { + public: + ExpParameter(); + virtual ~ExpParameter(); + + ExpParameter(const ExpParameter& from); + + inline ExpParameter& operator=(const ExpParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ExpParameter& default_instance(); + + static const ExpParameter* internal_default_instance(); + + void Swap(ExpParameter* other); + + // implements Message ---------------------------------------------- + + inline ExpParameter* New() const { return New(NULL); } + + ExpParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ExpParameter& from); + void MergeFrom(const ExpParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ExpParameter* other); + void UnsafeMergeFrom(const ExpParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float base = 1 [default = -1]; + bool has_base() const; + void clear_base(); + static const int kBaseFieldNumber = 1; + float base() const; + void set_base(float value); + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 2; + float scale() const; + void set_scale(float value); + + // optional float shift = 3 [default = 0]; + bool has_shift() const; + void clear_shift(); + static const int kShiftFieldNumber = 3; + float shift() const; + void set_shift(float value); + + // @@protoc_insertion_point(class_scope:caffe.ExpParameter) + private: + inline void set_has_base(); + inline void clear_has_base(); + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_shift(); + inline void clear_has_shift(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float shift_; + float base_; + float scale_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ExpParameter_default_instance_; + +// ------------------------------------------------------------------- + +class FlattenParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.FlattenParameter) */ { + public: + FlattenParameter(); + virtual ~FlattenParameter(); + + FlattenParameter(const FlattenParameter& from); + + inline FlattenParameter& operator=(const FlattenParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FlattenParameter& default_instance(); + + static const FlattenParameter* internal_default_instance(); + + void Swap(FlattenParameter* other); + + // implements Message ---------------------------------------------- + + inline FlattenParameter* New() const { return New(NULL); } + + FlattenParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FlattenParameter& from); + void MergeFrom(const FlattenParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FlattenParameter* other); + void UnsafeMergeFrom(const FlattenParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 1; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional int32 end_axis = 2 [default = -1]; + bool has_end_axis() const; + void clear_end_axis(); + static const int kEndAxisFieldNumber = 2; + ::google::protobuf::int32 end_axis() const; + void set_end_axis(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.FlattenParameter) + private: + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_end_axis(); + inline void clear_has_end_axis(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::int32 axis_; + ::google::protobuf::int32 end_axis_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed FlattenParameter_default_instance_; + +// ------------------------------------------------------------------- + +class HDF5DataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.HDF5DataParameter) */ { + public: + HDF5DataParameter(); + virtual ~HDF5DataParameter(); + + HDF5DataParameter(const HDF5DataParameter& from); + + inline HDF5DataParameter& operator=(const HDF5DataParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const HDF5DataParameter& default_instance(); + + static const HDF5DataParameter* internal_default_instance(); + + void Swap(HDF5DataParameter* other); + + // implements Message ---------------------------------------------- + + inline HDF5DataParameter* New() const { return New(NULL); } + + HDF5DataParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const HDF5DataParameter& from); + void MergeFrom(const HDF5DataParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(HDF5DataParameter* other); + void UnsafeMergeFrom(const HDF5DataParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string source = 1; + bool has_source() const; + void clear_source(); + static const int kSourceFieldNumber = 1; + const ::std::string& source() const; + void set_source(const ::std::string& value); + void set_source(const char* value); + void set_source(const char* value, size_t size); + ::std::string* mutable_source(); + ::std::string* release_source(); + void set_allocated_source(::std::string* source); + + // optional uint32 batch_size = 2; + bool has_batch_size() const; + void clear_batch_size(); + static const int kBatchSizeFieldNumber = 2; + ::google::protobuf::uint32 batch_size() const; + void set_batch_size(::google::protobuf::uint32 value); + + // optional bool shuffle = 3 [default = false]; + bool has_shuffle() const; + void clear_shuffle(); + static const int kShuffleFieldNumber = 3; + bool shuffle() const; + void set_shuffle(bool value); + + // @@protoc_insertion_point(class_scope:caffe.HDF5DataParameter) + private: + inline void set_has_source(); + inline void clear_has_source(); + inline void set_has_batch_size(); + inline void clear_has_batch_size(); + inline void set_has_shuffle(); + inline void clear_has_shuffle(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr source_; + ::google::protobuf::uint32 batch_size_; + bool shuffle_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed HDF5DataParameter_default_instance_; + +// ------------------------------------------------------------------- + +class HDF5OutputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.HDF5OutputParameter) */ { + public: + HDF5OutputParameter(); + virtual ~HDF5OutputParameter(); + + HDF5OutputParameter(const HDF5OutputParameter& from); + + inline HDF5OutputParameter& operator=(const HDF5OutputParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const HDF5OutputParameter& default_instance(); + + static const HDF5OutputParameter* internal_default_instance(); + + void Swap(HDF5OutputParameter* other); + + // implements Message ---------------------------------------------- + + inline HDF5OutputParameter* New() const { return New(NULL); } + + HDF5OutputParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const HDF5OutputParameter& from); + void MergeFrom(const HDF5OutputParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(HDF5OutputParameter* other); + void UnsafeMergeFrom(const HDF5OutputParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string file_name = 1; + bool has_file_name() const; + void clear_file_name(); + static const int kFileNameFieldNumber = 1; + const ::std::string& file_name() const; + void set_file_name(const ::std::string& value); + void set_file_name(const char* value); + void set_file_name(const char* value, size_t size); + ::std::string* mutable_file_name(); + ::std::string* release_file_name(); + void set_allocated_file_name(::std::string* file_name); + + // @@protoc_insertion_point(class_scope:caffe.HDF5OutputParameter) + private: + inline void set_has_file_name(); + inline void clear_has_file_name(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr file_name_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed HDF5OutputParameter_default_instance_; + +// ------------------------------------------------------------------- + +class HingeLossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.HingeLossParameter) */ { + public: + HingeLossParameter(); + virtual ~HingeLossParameter(); + + HingeLossParameter(const HingeLossParameter& from); + + inline HingeLossParameter& operator=(const HingeLossParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const HingeLossParameter& default_instance(); + + static const HingeLossParameter* internal_default_instance(); + + void Swap(HingeLossParameter* other); + + // implements Message ---------------------------------------------- + + inline HingeLossParameter* New() const { return New(NULL); } + + HingeLossParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const HingeLossParameter& from); + void MergeFrom(const HingeLossParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(HingeLossParameter* other); + void UnsafeMergeFrom(const HingeLossParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef HingeLossParameter_Norm Norm; + static const Norm L1 = + HingeLossParameter_Norm_L1; + static const Norm L2 = + HingeLossParameter_Norm_L2; + static inline bool Norm_IsValid(int value) { + return HingeLossParameter_Norm_IsValid(value); + } + static const Norm Norm_MIN = + HingeLossParameter_Norm_Norm_MIN; + static const Norm Norm_MAX = + HingeLossParameter_Norm_Norm_MAX; + static const int Norm_ARRAYSIZE = + HingeLossParameter_Norm_Norm_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Norm_descriptor() { + return HingeLossParameter_Norm_descriptor(); + } + static inline const ::std::string& Norm_Name(Norm value) { + return HingeLossParameter_Norm_Name(value); + } + static inline bool Norm_Parse(const ::std::string& name, + Norm* value) { + return HingeLossParameter_Norm_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1]; + bool has_norm() const; + void clear_norm(); + static const int kNormFieldNumber = 1; + ::caffe::HingeLossParameter_Norm norm() const; + void set_norm(::caffe::HingeLossParameter_Norm value); + + // @@protoc_insertion_point(class_scope:caffe.HingeLossParameter) + private: + inline void set_has_norm(); + inline void clear_has_norm(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + int norm_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed HingeLossParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ImageDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ImageDataParameter) */ { + public: + ImageDataParameter(); + virtual ~ImageDataParameter(); + + ImageDataParameter(const ImageDataParameter& from); + + inline ImageDataParameter& operator=(const ImageDataParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ImageDataParameter& default_instance(); + + static const ImageDataParameter* internal_default_instance(); + + void Swap(ImageDataParameter* other); + + // implements Message ---------------------------------------------- + + inline ImageDataParameter* New() const { return New(NULL); } + + ImageDataParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ImageDataParameter& from); + void MergeFrom(const ImageDataParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ImageDataParameter* other); + void UnsafeMergeFrom(const ImageDataParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string source = 1; + bool has_source() const; + void clear_source(); + static const int kSourceFieldNumber = 1; + const ::std::string& source() const; + void set_source(const ::std::string& value); + void set_source(const char* value); + void set_source(const char* value, size_t size); + ::std::string* mutable_source(); + ::std::string* release_source(); + void set_allocated_source(::std::string* source); + + // optional uint32 batch_size = 4 [default = 1]; + bool has_batch_size() const; + void clear_batch_size(); + static const int kBatchSizeFieldNumber = 4; + ::google::protobuf::uint32 batch_size() const; + void set_batch_size(::google::protobuf::uint32 value); + + // optional uint32 rand_skip = 7 [default = 0]; + bool has_rand_skip() const; + void clear_rand_skip(); + static const int kRandSkipFieldNumber = 7; + ::google::protobuf::uint32 rand_skip() const; + void set_rand_skip(::google::protobuf::uint32 value); + + // optional bool shuffle = 8 [default = false]; + bool has_shuffle() const; + void clear_shuffle(); + static const int kShuffleFieldNumber = 8; + bool shuffle() const; + void set_shuffle(bool value); + + // optional uint32 new_height = 9 [default = 0]; + bool has_new_height() const; + void clear_new_height(); + static const int kNewHeightFieldNumber = 9; + ::google::protobuf::uint32 new_height() const; + void set_new_height(::google::protobuf::uint32 value); + + // optional uint32 new_width = 10 [default = 0]; + bool has_new_width() const; + void clear_new_width(); + static const int kNewWidthFieldNumber = 10; + ::google::protobuf::uint32 new_width() const; + void set_new_width(::google::protobuf::uint32 value); + + // optional bool is_color = 11 [default = true]; + bool has_is_color() const; + void clear_is_color(); + static const int kIsColorFieldNumber = 11; + bool is_color() const; + void set_is_color(bool value); + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 2; + float scale() const; + void set_scale(float value); + + // optional string mean_file = 3; + bool has_mean_file() const; + void clear_mean_file(); + static const int kMeanFileFieldNumber = 3; + const ::std::string& mean_file() const; + void set_mean_file(const ::std::string& value); + void set_mean_file(const char* value); + void set_mean_file(const char* value, size_t size); + ::std::string* mutable_mean_file(); + ::std::string* release_mean_file(); + void set_allocated_mean_file(::std::string* mean_file); + + // optional uint32 crop_size = 5 [default = 0]; + bool has_crop_size() const; + void clear_crop_size(); + static const int kCropSizeFieldNumber = 5; + ::google::protobuf::uint32 crop_size() const; + void set_crop_size(::google::protobuf::uint32 value); + + // optional bool mirror = 6 [default = false]; + bool has_mirror() const; + void clear_mirror(); + static const int kMirrorFieldNumber = 6; + bool mirror() const; + void set_mirror(bool value); + + // optional string root_folder = 12 [default = ""]; + bool has_root_folder() const; + void clear_root_folder(); + static const int kRootFolderFieldNumber = 12; + const ::std::string& root_folder() const; + void set_root_folder(const ::std::string& value); + void set_root_folder(const char* value); + void set_root_folder(const char* value, size_t size); + ::std::string* mutable_root_folder(); + ::std::string* release_root_folder(); + void set_allocated_root_folder(::std::string* root_folder); + + // @@protoc_insertion_point(class_scope:caffe.ImageDataParameter) + private: + inline void set_has_source(); + inline void clear_has_source(); + inline void set_has_batch_size(); + inline void clear_has_batch_size(); + inline void set_has_rand_skip(); + inline void clear_has_rand_skip(); + inline void set_has_shuffle(); + inline void clear_has_shuffle(); + inline void set_has_new_height(); + inline void clear_has_new_height(); + inline void set_has_new_width(); + inline void clear_has_new_width(); + inline void set_has_is_color(); + inline void clear_has_is_color(); + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_mean_file(); + inline void clear_has_mean_file(); + inline void set_has_crop_size(); + inline void clear_has_crop_size(); + inline void set_has_mirror(); + inline void clear_has_mirror(); + inline void set_has_root_folder(); + inline void clear_has_root_folder(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr source_; + ::google::protobuf::internal::ArenaStringPtr mean_file_; + ::google::protobuf::internal::ArenaStringPtr root_folder_; + ::google::protobuf::uint32 rand_skip_; + ::google::protobuf::uint32 new_height_; + ::google::protobuf::uint32 new_width_; + bool shuffle_; + bool mirror_; + ::google::protobuf::uint32 crop_size_; + float scale_; + ::google::protobuf::uint32 batch_size_; + bool is_color_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ImageDataParameter_default_instance_; + +// ------------------------------------------------------------------- + +class InfogainLossParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.InfogainLossParameter) */ { + public: + InfogainLossParameter(); + virtual ~InfogainLossParameter(); + + InfogainLossParameter(const InfogainLossParameter& from); + + inline InfogainLossParameter& operator=(const InfogainLossParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InfogainLossParameter& default_instance(); + + static const InfogainLossParameter* internal_default_instance(); + + void Swap(InfogainLossParameter* other); + + // implements Message ---------------------------------------------- + + inline InfogainLossParameter* New() const { return New(NULL); } + + InfogainLossParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InfogainLossParameter& from); + void MergeFrom(const InfogainLossParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(InfogainLossParameter* other); + void UnsafeMergeFrom(const InfogainLossParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string source = 1; + bool has_source() const; + void clear_source(); + static const int kSourceFieldNumber = 1; + const ::std::string& source() const; + void set_source(const ::std::string& value); + void set_source(const char* value); + void set_source(const char* value, size_t size); + ::std::string* mutable_source(); + ::std::string* release_source(); + void set_allocated_source(::std::string* source); + + // @@protoc_insertion_point(class_scope:caffe.InfogainLossParameter) + private: + inline void set_has_source(); + inline void clear_has_source(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr source_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed InfogainLossParameter_default_instance_; + +// ------------------------------------------------------------------- + +class InnerProductParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.InnerProductParameter) */ { + public: + InnerProductParameter(); + virtual ~InnerProductParameter(); + + InnerProductParameter(const InnerProductParameter& from); + + inline InnerProductParameter& operator=(const InnerProductParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InnerProductParameter& default_instance(); + + static const InnerProductParameter* internal_default_instance(); + + void Swap(InnerProductParameter* other); + + // implements Message ---------------------------------------------- + + inline InnerProductParameter* New() const { return New(NULL); } + + InnerProductParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InnerProductParameter& from); + void MergeFrom(const InnerProductParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(InnerProductParameter* other); + void UnsafeMergeFrom(const InnerProductParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 num_output = 1; + bool has_num_output() const; + void clear_num_output(); + static const int kNumOutputFieldNumber = 1; + ::google::protobuf::uint32 num_output() const; + void set_num_output(::google::protobuf::uint32 value); + + // optional bool bias_term = 2 [default = true]; + bool has_bias_term() const; + void clear_bias_term(); + static const int kBiasTermFieldNumber = 2; + bool bias_term() const; + void set_bias_term(bool value); + + // optional .caffe.FillerParameter weight_filler = 3; + bool has_weight_filler() const; + void clear_weight_filler(); + static const int kWeightFillerFieldNumber = 3; + const ::caffe::FillerParameter& weight_filler() const; + ::caffe::FillerParameter* mutable_weight_filler(); + ::caffe::FillerParameter* release_weight_filler(); + void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler); + + // optional .caffe.FillerParameter bias_filler = 4; + bool has_bias_filler() const; + void clear_bias_filler(); + static const int kBiasFillerFieldNumber = 4; + const ::caffe::FillerParameter& bias_filler() const; + ::caffe::FillerParameter* mutable_bias_filler(); + ::caffe::FillerParameter* release_bias_filler(); + void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler); + + // optional int32 axis = 5 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 5; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional bool transpose = 6 [default = false]; + bool has_transpose() const; + void clear_transpose(); + static const int kTransposeFieldNumber = 6; + bool transpose() const; + void set_transpose(bool value); + + // @@protoc_insertion_point(class_scope:caffe.InnerProductParameter) + private: + inline void set_has_num_output(); + inline void clear_has_num_output(); + inline void set_has_bias_term(); + inline void clear_has_bias_term(); + inline void set_has_weight_filler(); + inline void clear_has_weight_filler(); + inline void set_has_bias_filler(); + inline void clear_has_bias_filler(); + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_transpose(); + inline void clear_has_transpose(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::FillerParameter* weight_filler_; + ::caffe::FillerParameter* bias_filler_; + ::google::protobuf::uint32 num_output_; + bool transpose_; + bool bias_term_; + ::google::protobuf::int32 axis_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed InnerProductParameter_default_instance_; + +// ------------------------------------------------------------------- + +class InputParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.InputParameter) */ { + public: + InputParameter(); + virtual ~InputParameter(); + + InputParameter(const InputParameter& from); + + inline InputParameter& operator=(const InputParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InputParameter& default_instance(); + + static const InputParameter* internal_default_instance(); + + void Swap(InputParameter* other); + + // implements Message ---------------------------------------------- + + inline InputParameter* New() const { return New(NULL); } + + InputParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InputParameter& from); + void MergeFrom(const InputParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(InputParameter* other); + void UnsafeMergeFrom(const InputParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .caffe.BlobShape shape = 1; + int shape_size() const; + void clear_shape(); + static const int kShapeFieldNumber = 1; + const ::caffe::BlobShape& shape(int index) const; + ::caffe::BlobShape* mutable_shape(int index); + ::caffe::BlobShape* add_shape(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* + mutable_shape(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& + shape() const; + + // @@protoc_insertion_point(class_scope:caffe.InputParameter) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape > shape_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed InputParameter_default_instance_; + +// ------------------------------------------------------------------- + +class LogParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.LogParameter) */ { + public: + LogParameter(); + virtual ~LogParameter(); + + LogParameter(const LogParameter& from); + + inline LogParameter& operator=(const LogParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LogParameter& default_instance(); + + static const LogParameter* internal_default_instance(); + + void Swap(LogParameter* other); + + // implements Message ---------------------------------------------- + + inline LogParameter* New() const { return New(NULL); } + + LogParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LogParameter& from); + void MergeFrom(const LogParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LogParameter* other); + void UnsafeMergeFrom(const LogParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float base = 1 [default = -1]; + bool has_base() const; + void clear_base(); + static const int kBaseFieldNumber = 1; + float base() const; + void set_base(float value); + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 2; + float scale() const; + void set_scale(float value); + + // optional float shift = 3 [default = 0]; + bool has_shift() const; + void clear_shift(); + static const int kShiftFieldNumber = 3; + float shift() const; + void set_shift(float value); + + // @@protoc_insertion_point(class_scope:caffe.LogParameter) + private: + inline void set_has_base(); + inline void clear_has_base(); + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_shift(); + inline void clear_has_shift(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float shift_; + float base_; + float scale_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed LogParameter_default_instance_; + +// ------------------------------------------------------------------- + +class LRNParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.LRNParameter) */ { + public: + LRNParameter(); + virtual ~LRNParameter(); + + LRNParameter(const LRNParameter& from); + + inline LRNParameter& operator=(const LRNParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LRNParameter& default_instance(); + + static const LRNParameter* internal_default_instance(); + + void Swap(LRNParameter* other); + + // implements Message ---------------------------------------------- + + inline LRNParameter* New() const { return New(NULL); } + + LRNParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LRNParameter& from); + void MergeFrom(const LRNParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LRNParameter* other); + void UnsafeMergeFrom(const LRNParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef LRNParameter_NormRegion NormRegion; + static const NormRegion ACROSS_CHANNELS = + LRNParameter_NormRegion_ACROSS_CHANNELS; + static const NormRegion WITHIN_CHANNEL = + LRNParameter_NormRegion_WITHIN_CHANNEL; + static inline bool NormRegion_IsValid(int value) { + return LRNParameter_NormRegion_IsValid(value); + } + static const NormRegion NormRegion_MIN = + LRNParameter_NormRegion_NormRegion_MIN; + static const NormRegion NormRegion_MAX = + LRNParameter_NormRegion_NormRegion_MAX; + static const int NormRegion_ARRAYSIZE = + LRNParameter_NormRegion_NormRegion_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + NormRegion_descriptor() { + return LRNParameter_NormRegion_descriptor(); + } + static inline const ::std::string& NormRegion_Name(NormRegion value) { + return LRNParameter_NormRegion_Name(value); + } + static inline bool NormRegion_Parse(const ::std::string& name, + NormRegion* value) { + return LRNParameter_NormRegion_Parse(name, value); + } + + typedef LRNParameter_Engine Engine; + static const Engine DEFAULT = + LRNParameter_Engine_DEFAULT; + static const Engine CAFFE = + LRNParameter_Engine_CAFFE; + static const Engine CUDNN = + LRNParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return LRNParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + LRNParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + LRNParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + LRNParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return LRNParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return LRNParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return LRNParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional uint32 local_size = 1 [default = 5]; + bool has_local_size() const; + void clear_local_size(); + static const int kLocalSizeFieldNumber = 1; + ::google::protobuf::uint32 local_size() const; + void set_local_size(::google::protobuf::uint32 value); + + // optional float alpha = 2 [default = 1]; + bool has_alpha() const; + void clear_alpha(); + static const int kAlphaFieldNumber = 2; + float alpha() const; + void set_alpha(float value); + + // optional float beta = 3 [default = 0.75]; + bool has_beta() const; + void clear_beta(); + static const int kBetaFieldNumber = 3; + float beta() const; + void set_beta(float value); + + // optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + bool has_norm_region() const; + void clear_norm_region(); + static const int kNormRegionFieldNumber = 4; + ::caffe::LRNParameter_NormRegion norm_region() const; + void set_norm_region(::caffe::LRNParameter_NormRegion value); + + // optional float k = 5 [default = 1]; + bool has_k() const; + void clear_k(); + static const int kKFieldNumber = 5; + float k() const; + void set_k(float value); + + // optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 6; + ::caffe::LRNParameter_Engine engine() const; + void set_engine(::caffe::LRNParameter_Engine value); + + // @@protoc_insertion_point(class_scope:caffe.LRNParameter) + private: + inline void set_has_local_size(); + inline void clear_has_local_size(); + inline void set_has_alpha(); + inline void clear_has_alpha(); + inline void set_has_beta(); + inline void clear_has_beta(); + inline void set_has_norm_region(); + inline void clear_has_norm_region(); + inline void set_has_k(); + inline void clear_has_k(); + inline void set_has_engine(); + inline void clear_has_engine(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + int norm_region_; + int engine_; + ::google::protobuf::uint32 local_size_; + float alpha_; + float beta_; + float k_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed LRNParameter_default_instance_; + +// ------------------------------------------------------------------- + +class MemoryDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.MemoryDataParameter) */ { + public: + MemoryDataParameter(); + virtual ~MemoryDataParameter(); + + MemoryDataParameter(const MemoryDataParameter& from); + + inline MemoryDataParameter& operator=(const MemoryDataParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const MemoryDataParameter& default_instance(); + + static const MemoryDataParameter* internal_default_instance(); + + void Swap(MemoryDataParameter* other); + + // implements Message ---------------------------------------------- + + inline MemoryDataParameter* New() const { return New(NULL); } + + MemoryDataParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const MemoryDataParameter& from); + void MergeFrom(const MemoryDataParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(MemoryDataParameter* other); + void UnsafeMergeFrom(const MemoryDataParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 batch_size = 1; + bool has_batch_size() const; + void clear_batch_size(); + static const int kBatchSizeFieldNumber = 1; + ::google::protobuf::uint32 batch_size() const; + void set_batch_size(::google::protobuf::uint32 value); + + // optional uint32 channels = 2; + bool has_channels() const; + void clear_channels(); + static const int kChannelsFieldNumber = 2; + ::google::protobuf::uint32 channels() const; + void set_channels(::google::protobuf::uint32 value); + + // optional uint32 height = 3; + bool has_height() const; + void clear_height(); + static const int kHeightFieldNumber = 3; + ::google::protobuf::uint32 height() const; + void set_height(::google::protobuf::uint32 value); + + // optional uint32 width = 4; + bool has_width() const; + void clear_width(); + static const int kWidthFieldNumber = 4; + ::google::protobuf::uint32 width() const; + void set_width(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:caffe.MemoryDataParameter) + private: + inline void set_has_batch_size(); + inline void clear_has_batch_size(); + inline void set_has_channels(); + inline void clear_has_channels(); + inline void set_has_height(); + inline void clear_has_height(); + inline void set_has_width(); + inline void clear_has_width(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::uint32 batch_size_; + ::google::protobuf::uint32 channels_; + ::google::protobuf::uint32 height_; + ::google::protobuf::uint32 width_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed MemoryDataParameter_default_instance_; + +// ------------------------------------------------------------------- + +class MVNParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.MVNParameter) */ { + public: + MVNParameter(); + virtual ~MVNParameter(); + + MVNParameter(const MVNParameter& from); + + inline MVNParameter& operator=(const MVNParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const MVNParameter& default_instance(); + + static const MVNParameter* internal_default_instance(); + + void Swap(MVNParameter* other); + + // implements Message ---------------------------------------------- + + inline MVNParameter* New() const { return New(NULL); } + + MVNParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const MVNParameter& from); + void MergeFrom(const MVNParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(MVNParameter* other); + void UnsafeMergeFrom(const MVNParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool normalize_variance = 1 [default = true]; + bool has_normalize_variance() const; + void clear_normalize_variance(); + static const int kNormalizeVarianceFieldNumber = 1; + bool normalize_variance() const; + void set_normalize_variance(bool value); + + // optional bool across_channels = 2 [default = false]; + bool has_across_channels() const; + void clear_across_channels(); + static const int kAcrossChannelsFieldNumber = 2; + bool across_channels() const; + void set_across_channels(bool value); + + // optional float eps = 3 [default = 1e-09]; + bool has_eps() const; + void clear_eps(); + static const int kEpsFieldNumber = 3; + float eps() const; + void set_eps(float value); + + // @@protoc_insertion_point(class_scope:caffe.MVNParameter) + private: + inline void set_has_normalize_variance(); + inline void clear_has_normalize_variance(); + inline void set_has_across_channels(); + inline void clear_has_across_channels(); + inline void set_has_eps(); + inline void clear_has_eps(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + bool across_channels_; + bool normalize_variance_; + float eps_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed MVNParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ParameterParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ParameterParameter) */ { + public: + ParameterParameter(); + virtual ~ParameterParameter(); + + ParameterParameter(const ParameterParameter& from); + + inline ParameterParameter& operator=(const ParameterParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ParameterParameter& default_instance(); + + static const ParameterParameter* internal_default_instance(); + + void Swap(ParameterParameter* other); + + // implements Message ---------------------------------------------- + + inline ParameterParameter* New() const { return New(NULL); } + + ParameterParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ParameterParameter& from); + void MergeFrom(const ParameterParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ParameterParameter* other); + void UnsafeMergeFrom(const ParameterParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .caffe.BlobShape shape = 1; + bool has_shape() const; + void clear_shape(); + static const int kShapeFieldNumber = 1; + const ::caffe::BlobShape& shape() const; + ::caffe::BlobShape* mutable_shape(); + ::caffe::BlobShape* release_shape(); + void set_allocated_shape(::caffe::BlobShape* shape); + + // @@protoc_insertion_point(class_scope:caffe.ParameterParameter) + private: + inline void set_has_shape(); + inline void clear_has_shape(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::BlobShape* shape_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ParameterParameter_default_instance_; + +// ------------------------------------------------------------------- + +class PoolingParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.PoolingParameter) */ { + public: + PoolingParameter(); + virtual ~PoolingParameter(); + + PoolingParameter(const PoolingParameter& from); + + inline PoolingParameter& operator=(const PoolingParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PoolingParameter& default_instance(); + + static const PoolingParameter* internal_default_instance(); + + void Swap(PoolingParameter* other); + + // implements Message ---------------------------------------------- + + inline PoolingParameter* New() const { return New(NULL); } + + PoolingParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PoolingParameter& from); + void MergeFrom(const PoolingParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PoolingParameter* other); + void UnsafeMergeFrom(const PoolingParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef PoolingParameter_PoolMethod PoolMethod; + static const PoolMethod MAX = + PoolingParameter_PoolMethod_MAX; + static const PoolMethod AVE = + PoolingParameter_PoolMethod_AVE; + static const PoolMethod STOCHASTIC = + PoolingParameter_PoolMethod_STOCHASTIC; + static inline bool PoolMethod_IsValid(int value) { + return PoolingParameter_PoolMethod_IsValid(value); + } + static const PoolMethod PoolMethod_MIN = + PoolingParameter_PoolMethod_PoolMethod_MIN; + static const PoolMethod PoolMethod_MAX = + PoolingParameter_PoolMethod_PoolMethod_MAX; + static const int PoolMethod_ARRAYSIZE = + PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + PoolMethod_descriptor() { + return PoolingParameter_PoolMethod_descriptor(); + } + static inline const ::std::string& PoolMethod_Name(PoolMethod value) { + return PoolingParameter_PoolMethod_Name(value); + } + static inline bool PoolMethod_Parse(const ::std::string& name, + PoolMethod* value) { + return PoolingParameter_PoolMethod_Parse(name, value); + } + + typedef PoolingParameter_Engine Engine; + static const Engine DEFAULT = + PoolingParameter_Engine_DEFAULT; + static const Engine CAFFE = + PoolingParameter_Engine_CAFFE; + static const Engine CUDNN = + PoolingParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return PoolingParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + PoolingParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + PoolingParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + PoolingParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return PoolingParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return PoolingParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return PoolingParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; + bool has_pool() const; + void clear_pool(); + static const int kPoolFieldNumber = 1; + ::caffe::PoolingParameter_PoolMethod pool() const; + void set_pool(::caffe::PoolingParameter_PoolMethod value); + + // optional uint32 pad = 4 [default = 0]; + bool has_pad() const; + void clear_pad(); + static const int kPadFieldNumber = 4; + ::google::protobuf::uint32 pad() const; + void set_pad(::google::protobuf::uint32 value); + + // optional uint32 pad_h = 9 [default = 0]; + bool has_pad_h() const; + void clear_pad_h(); + static const int kPadHFieldNumber = 9; + ::google::protobuf::uint32 pad_h() const; + void set_pad_h(::google::protobuf::uint32 value); + + // optional uint32 pad_w = 10 [default = 0]; + bool has_pad_w() const; + void clear_pad_w(); + static const int kPadWFieldNumber = 10; + ::google::protobuf::uint32 pad_w() const; + void set_pad_w(::google::protobuf::uint32 value); + + // optional uint32 kernel_size = 2; + bool has_kernel_size() const; + void clear_kernel_size(); + static const int kKernelSizeFieldNumber = 2; + ::google::protobuf::uint32 kernel_size() const; + void set_kernel_size(::google::protobuf::uint32 value); + + // optional uint32 kernel_h = 5; + bool has_kernel_h() const; + void clear_kernel_h(); + static const int kKernelHFieldNumber = 5; + ::google::protobuf::uint32 kernel_h() const; + void set_kernel_h(::google::protobuf::uint32 value); + + // optional uint32 kernel_w = 6; + bool has_kernel_w() const; + void clear_kernel_w(); + static const int kKernelWFieldNumber = 6; + ::google::protobuf::uint32 kernel_w() const; + void set_kernel_w(::google::protobuf::uint32 value); + + // optional uint32 stride = 3 [default = 1]; + bool has_stride() const; + void clear_stride(); + static const int kStrideFieldNumber = 3; + ::google::protobuf::uint32 stride() const; + void set_stride(::google::protobuf::uint32 value); + + // optional uint32 stride_h = 7; + bool has_stride_h() const; + void clear_stride_h(); + static const int kStrideHFieldNumber = 7; + ::google::protobuf::uint32 stride_h() const; + void set_stride_h(::google::protobuf::uint32 value); + + // optional uint32 stride_w = 8; + bool has_stride_w() const; + void clear_stride_w(); + static const int kStrideWFieldNumber = 8; + ::google::protobuf::uint32 stride_w() const; + void set_stride_w(::google::protobuf::uint32 value); + + // optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 11; + ::caffe::PoolingParameter_Engine engine() const; + void set_engine(::caffe::PoolingParameter_Engine value); + + // optional bool global_pooling = 12 [default = false]; + bool has_global_pooling() const; + void clear_global_pooling(); + static const int kGlobalPoolingFieldNumber = 12; + bool global_pooling() const; + void set_global_pooling(bool value); + + // @@protoc_insertion_point(class_scope:caffe.PoolingParameter) + private: + inline void set_has_pool(); + inline void clear_has_pool(); + inline void set_has_pad(); + inline void clear_has_pad(); + inline void set_has_pad_h(); + inline void clear_has_pad_h(); + inline void set_has_pad_w(); + inline void clear_has_pad_w(); + inline void set_has_kernel_size(); + inline void clear_has_kernel_size(); + inline void set_has_kernel_h(); + inline void clear_has_kernel_h(); + inline void set_has_kernel_w(); + inline void clear_has_kernel_w(); + inline void set_has_stride(); + inline void clear_has_stride(); + inline void set_has_stride_h(); + inline void clear_has_stride_h(); + inline void set_has_stride_w(); + inline void clear_has_stride_w(); + inline void set_has_engine(); + inline void clear_has_engine(); + inline void set_has_global_pooling(); + inline void clear_has_global_pooling(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + int pool_; + ::google::protobuf::uint32 pad_; + ::google::protobuf::uint32 pad_h_; + ::google::protobuf::uint32 pad_w_; + ::google::protobuf::uint32 kernel_size_; + ::google::protobuf::uint32 kernel_h_; + ::google::protobuf::uint32 kernel_w_; + ::google::protobuf::uint32 stride_h_; + ::google::protobuf::uint32 stride_w_; + int engine_; + bool global_pooling_; + ::google::protobuf::uint32 stride_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed PoolingParameter_default_instance_; + +// ------------------------------------------------------------------- + +class PowerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.PowerParameter) */ { + public: + PowerParameter(); + virtual ~PowerParameter(); + + PowerParameter(const PowerParameter& from); + + inline PowerParameter& operator=(const PowerParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PowerParameter& default_instance(); + + static const PowerParameter* internal_default_instance(); + + void Swap(PowerParameter* other); + + // implements Message ---------------------------------------------- + + inline PowerParameter* New() const { return New(NULL); } + + PowerParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PowerParameter& from); + void MergeFrom(const PowerParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PowerParameter* other); + void UnsafeMergeFrom(const PowerParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float power = 1 [default = 1]; + bool has_power() const; + void clear_power(); + static const int kPowerFieldNumber = 1; + float power() const; + void set_power(float value); + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 2; + float scale() const; + void set_scale(float value); + + // optional float shift = 3 [default = 0]; + bool has_shift() const; + void clear_shift(); + static const int kShiftFieldNumber = 3; + float shift() const; + void set_shift(float value); + + // @@protoc_insertion_point(class_scope:caffe.PowerParameter) + private: + inline void set_has_power(); + inline void clear_has_power(); + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_shift(); + inline void clear_has_shift(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float shift_; + float power_; + float scale_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed PowerParameter_default_instance_; + +// ------------------------------------------------------------------- + +class PythonParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.PythonParameter) */ { + public: + PythonParameter(); + virtual ~PythonParameter(); + + PythonParameter(const PythonParameter& from); + + inline PythonParameter& operator=(const PythonParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PythonParameter& default_instance(); + + static const PythonParameter* internal_default_instance(); + + void Swap(PythonParameter* other); + + // implements Message ---------------------------------------------- + + inline PythonParameter* New() const { return New(NULL); } + + PythonParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PythonParameter& from); + void MergeFrom(const PythonParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PythonParameter* other); + void UnsafeMergeFrom(const PythonParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string module = 1; + bool has_module() const; + void clear_module(); + static const int kModuleFieldNumber = 1; + const ::std::string& module() const; + void set_module(const ::std::string& value); + void set_module(const char* value); + void set_module(const char* value, size_t size); + ::std::string* mutable_module(); + ::std::string* release_module(); + void set_allocated_module(::std::string* module); + + // optional string layer = 2; + bool has_layer() const; + void clear_layer(); + static const int kLayerFieldNumber = 2; + const ::std::string& layer() const; + void set_layer(const ::std::string& value); + void set_layer(const char* value); + void set_layer(const char* value, size_t size); + ::std::string* mutable_layer(); + ::std::string* release_layer(); + void set_allocated_layer(::std::string* layer); + + // optional string param_str = 3 [default = ""]; + bool has_param_str() const; + void clear_param_str(); + static const int kParamStrFieldNumber = 3; + const ::std::string& param_str() const; + void set_param_str(const ::std::string& value); + void set_param_str(const char* value); + void set_param_str(const char* value, size_t size); + ::std::string* mutable_param_str(); + ::std::string* release_param_str(); + void set_allocated_param_str(::std::string* param_str); + + // optional bool share_in_parallel = 4 [default = false]; + bool has_share_in_parallel() const; + void clear_share_in_parallel(); + static const int kShareInParallelFieldNumber = 4; + bool share_in_parallel() const; + void set_share_in_parallel(bool value); + + // @@protoc_insertion_point(class_scope:caffe.PythonParameter) + private: + inline void set_has_module(); + inline void clear_has_module(); + inline void set_has_layer(); + inline void clear_has_layer(); + inline void set_has_param_str(); + inline void clear_has_param_str(); + inline void set_has_share_in_parallel(); + inline void clear_has_share_in_parallel(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr module_; + ::google::protobuf::internal::ArenaStringPtr layer_; + ::google::protobuf::internal::ArenaStringPtr param_str_; + bool share_in_parallel_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed PythonParameter_default_instance_; + +// ------------------------------------------------------------------- + +class RecurrentParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.RecurrentParameter) */ { + public: + RecurrentParameter(); + virtual ~RecurrentParameter(); + + RecurrentParameter(const RecurrentParameter& from); + + inline RecurrentParameter& operator=(const RecurrentParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RecurrentParameter& default_instance(); + + static const RecurrentParameter* internal_default_instance(); + + void Swap(RecurrentParameter* other); + + // implements Message ---------------------------------------------- + + inline RecurrentParameter* New() const { return New(NULL); } + + RecurrentParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RecurrentParameter& from); + void MergeFrom(const RecurrentParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(RecurrentParameter* other); + void UnsafeMergeFrom(const RecurrentParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 num_output = 1 [default = 0]; + bool has_num_output() const; + void clear_num_output(); + static const int kNumOutputFieldNumber = 1; + ::google::protobuf::uint32 num_output() const; + void set_num_output(::google::protobuf::uint32 value); + + // optional .caffe.FillerParameter weight_filler = 2; + bool has_weight_filler() const; + void clear_weight_filler(); + static const int kWeightFillerFieldNumber = 2; + const ::caffe::FillerParameter& weight_filler() const; + ::caffe::FillerParameter* mutable_weight_filler(); + ::caffe::FillerParameter* release_weight_filler(); + void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler); + + // optional .caffe.FillerParameter bias_filler = 3; + bool has_bias_filler() const; + void clear_bias_filler(); + static const int kBiasFillerFieldNumber = 3; + const ::caffe::FillerParameter& bias_filler() const; + ::caffe::FillerParameter* mutable_bias_filler(); + ::caffe::FillerParameter* release_bias_filler(); + void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler); + + // optional bool debug_info = 4 [default = false]; + bool has_debug_info() const; + void clear_debug_info(); + static const int kDebugInfoFieldNumber = 4; + bool debug_info() const; + void set_debug_info(bool value); + + // optional bool expose_hidden = 5 [default = false]; + bool has_expose_hidden() const; + void clear_expose_hidden(); + static const int kExposeHiddenFieldNumber = 5; + bool expose_hidden() const; + void set_expose_hidden(bool value); + + // @@protoc_insertion_point(class_scope:caffe.RecurrentParameter) + private: + inline void set_has_num_output(); + inline void clear_has_num_output(); + inline void set_has_weight_filler(); + inline void clear_has_weight_filler(); + inline void set_has_bias_filler(); + inline void clear_has_bias_filler(); + inline void set_has_debug_info(); + inline void clear_has_debug_info(); + inline void set_has_expose_hidden(); + inline void clear_has_expose_hidden(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::FillerParameter* weight_filler_; + ::caffe::FillerParameter* bias_filler_; + ::google::protobuf::uint32 num_output_; + bool debug_info_; + bool expose_hidden_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed RecurrentParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ReductionParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ReductionParameter) */ { + public: + ReductionParameter(); + virtual ~ReductionParameter(); + + ReductionParameter(const ReductionParameter& from); + + inline ReductionParameter& operator=(const ReductionParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ReductionParameter& default_instance(); + + static const ReductionParameter* internal_default_instance(); + + void Swap(ReductionParameter* other); + + // implements Message ---------------------------------------------- + + inline ReductionParameter* New() const { return New(NULL); } + + ReductionParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ReductionParameter& from); + void MergeFrom(const ReductionParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ReductionParameter* other); + void UnsafeMergeFrom(const ReductionParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef ReductionParameter_ReductionOp ReductionOp; + static const ReductionOp SUM = + ReductionParameter_ReductionOp_SUM; + static const ReductionOp ASUM = + ReductionParameter_ReductionOp_ASUM; + static const ReductionOp SUMSQ = + ReductionParameter_ReductionOp_SUMSQ; + static const ReductionOp MEAN = + ReductionParameter_ReductionOp_MEAN; + static inline bool ReductionOp_IsValid(int value) { + return ReductionParameter_ReductionOp_IsValid(value); + } + static const ReductionOp ReductionOp_MIN = + ReductionParameter_ReductionOp_ReductionOp_MIN; + static const ReductionOp ReductionOp_MAX = + ReductionParameter_ReductionOp_ReductionOp_MAX; + static const int ReductionOp_ARRAYSIZE = + ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + ReductionOp_descriptor() { + return ReductionParameter_ReductionOp_descriptor(); + } + static inline const ::std::string& ReductionOp_Name(ReductionOp value) { + return ReductionParameter_ReductionOp_Name(value); + } + static inline bool ReductionOp_Parse(const ::std::string& name, + ReductionOp* value) { + return ReductionParameter_ReductionOp_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; + bool has_operation() const; + void clear_operation(); + static const int kOperationFieldNumber = 1; + ::caffe::ReductionParameter_ReductionOp operation() const; + void set_operation(::caffe::ReductionParameter_ReductionOp value); + + // optional int32 axis = 2 [default = 0]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 2; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional float coeff = 3 [default = 1]; + bool has_coeff() const; + void clear_coeff(); + static const int kCoeffFieldNumber = 3; + float coeff() const; + void set_coeff(float value); + + // @@protoc_insertion_point(class_scope:caffe.ReductionParameter) + private: + inline void set_has_operation(); + inline void clear_has_operation(); + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_coeff(); + inline void clear_has_coeff(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::int32 axis_; + int operation_; + float coeff_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ReductionParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ReLUParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ReLUParameter) */ { + public: + ReLUParameter(); + virtual ~ReLUParameter(); + + ReLUParameter(const ReLUParameter& from); + + inline ReLUParameter& operator=(const ReLUParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ReLUParameter& default_instance(); + + static const ReLUParameter* internal_default_instance(); + + void Swap(ReLUParameter* other); + + // implements Message ---------------------------------------------- + + inline ReLUParameter* New() const { return New(NULL); } + + ReLUParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ReLUParameter& from); + void MergeFrom(const ReLUParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ReLUParameter* other); + void UnsafeMergeFrom(const ReLUParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef ReLUParameter_Engine Engine; + static const Engine DEFAULT = + ReLUParameter_Engine_DEFAULT; + static const Engine CAFFE = + ReLUParameter_Engine_CAFFE; + static const Engine CUDNN = + ReLUParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return ReLUParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + ReLUParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + ReLUParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + ReLUParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return ReLUParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return ReLUParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return ReLUParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional float negative_slope = 1 [default = 0]; + bool has_negative_slope() const; + void clear_negative_slope(); + static const int kNegativeSlopeFieldNumber = 1; + float negative_slope() const; + void set_negative_slope(float value); + + // optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 2; + ::caffe::ReLUParameter_Engine engine() const; + void set_engine(::caffe::ReLUParameter_Engine value); + + // @@protoc_insertion_point(class_scope:caffe.ReLUParameter) + private: + inline void set_has_negative_slope(); + inline void clear_has_negative_slope(); + inline void set_has_engine(); + inline void clear_has_engine(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float negative_slope_; + int engine_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ReLUParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ReshapeParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ReshapeParameter) */ { + public: + ReshapeParameter(); + virtual ~ReshapeParameter(); + + ReshapeParameter(const ReshapeParameter& from); + + inline ReshapeParameter& operator=(const ReshapeParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ReshapeParameter& default_instance(); + + static const ReshapeParameter* internal_default_instance(); + + void Swap(ReshapeParameter* other); + + // implements Message ---------------------------------------------- + + inline ReshapeParameter* New() const { return New(NULL); } + + ReshapeParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ReshapeParameter& from); + void MergeFrom(const ReshapeParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ReshapeParameter* other); + void UnsafeMergeFrom(const ReshapeParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .caffe.BlobShape shape = 1; + bool has_shape() const; + void clear_shape(); + static const int kShapeFieldNumber = 1; + const ::caffe::BlobShape& shape() const; + ::caffe::BlobShape* mutable_shape(); + ::caffe::BlobShape* release_shape(); + void set_allocated_shape(::caffe::BlobShape* shape); + + // optional int32 axis = 2 [default = 0]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 2; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional int32 num_axes = 3 [default = -1]; + bool has_num_axes() const; + void clear_num_axes(); + static const int kNumAxesFieldNumber = 3; + ::google::protobuf::int32 num_axes() const; + void set_num_axes(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.ReshapeParameter) + private: + inline void set_has_shape(); + inline void clear_has_shape(); + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_num_axes(); + inline void clear_has_num_axes(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::BlobShape* shape_; + ::google::protobuf::int32 axis_; + ::google::protobuf::int32 num_axes_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ReshapeParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ScaleParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ScaleParameter) */ { + public: + ScaleParameter(); + virtual ~ScaleParameter(); + + ScaleParameter(const ScaleParameter& from); + + inline ScaleParameter& operator=(const ScaleParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ScaleParameter& default_instance(); + + static const ScaleParameter* internal_default_instance(); + + void Swap(ScaleParameter* other); + + // implements Message ---------------------------------------------- + + inline ScaleParameter* New() const { return New(NULL); } + + ScaleParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ScaleParameter& from); + void MergeFrom(const ScaleParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ScaleParameter* other); + void UnsafeMergeFrom(const ScaleParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 1; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional int32 num_axes = 2 [default = 1]; + bool has_num_axes() const; + void clear_num_axes(); + static const int kNumAxesFieldNumber = 2; + ::google::protobuf::int32 num_axes() const; + void set_num_axes(::google::protobuf::int32 value); + + // optional .caffe.FillerParameter filler = 3; + bool has_filler() const; + void clear_filler(); + static const int kFillerFieldNumber = 3; + const ::caffe::FillerParameter& filler() const; + ::caffe::FillerParameter* mutable_filler(); + ::caffe::FillerParameter* release_filler(); + void set_allocated_filler(::caffe::FillerParameter* filler); + + // optional bool bias_term = 4 [default = false]; + bool has_bias_term() const; + void clear_bias_term(); + static const int kBiasTermFieldNumber = 4; + bool bias_term() const; + void set_bias_term(bool value); + + // optional .caffe.FillerParameter bias_filler = 5; + bool has_bias_filler() const; + void clear_bias_filler(); + static const int kBiasFillerFieldNumber = 5; + const ::caffe::FillerParameter& bias_filler() const; + ::caffe::FillerParameter* mutable_bias_filler(); + ::caffe::FillerParameter* release_bias_filler(); + void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler); + + // @@protoc_insertion_point(class_scope:caffe.ScaleParameter) + private: + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_num_axes(); + inline void clear_has_num_axes(); + inline void set_has_filler(); + inline void clear_has_filler(); + inline void set_has_bias_term(); + inline void clear_has_bias_term(); + inline void set_has_bias_filler(); + inline void clear_has_bias_filler(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::FillerParameter* filler_; + ::caffe::FillerParameter* bias_filler_; + bool bias_term_; + ::google::protobuf::int32 axis_; + ::google::protobuf::int32 num_axes_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ScaleParameter_default_instance_; + +// ------------------------------------------------------------------- + +class SigmoidParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.SigmoidParameter) */ { + public: + SigmoidParameter(); + virtual ~SigmoidParameter(); + + SigmoidParameter(const SigmoidParameter& from); + + inline SigmoidParameter& operator=(const SigmoidParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SigmoidParameter& default_instance(); + + static const SigmoidParameter* internal_default_instance(); + + void Swap(SigmoidParameter* other); + + // implements Message ---------------------------------------------- + + inline SigmoidParameter* New() const { return New(NULL); } + + SigmoidParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SigmoidParameter& from); + void MergeFrom(const SigmoidParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SigmoidParameter* other); + void UnsafeMergeFrom(const SigmoidParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef SigmoidParameter_Engine Engine; + static const Engine DEFAULT = + SigmoidParameter_Engine_DEFAULT; + static const Engine CAFFE = + SigmoidParameter_Engine_CAFFE; + static const Engine CUDNN = + SigmoidParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return SigmoidParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + SigmoidParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + SigmoidParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + SigmoidParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return SigmoidParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return SigmoidParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return SigmoidParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 1; + ::caffe::SigmoidParameter_Engine engine() const; + void set_engine(::caffe::SigmoidParameter_Engine value); + + // @@protoc_insertion_point(class_scope:caffe.SigmoidParameter) + private: + inline void set_has_engine(); + inline void clear_has_engine(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + int engine_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed SigmoidParameter_default_instance_; + +// ------------------------------------------------------------------- + +class SliceParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.SliceParameter) */ { + public: + SliceParameter(); + virtual ~SliceParameter(); + + SliceParameter(const SliceParameter& from); + + inline SliceParameter& operator=(const SliceParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SliceParameter& default_instance(); + + static const SliceParameter* internal_default_instance(); + + void Swap(SliceParameter* other); + + // implements Message ---------------------------------------------- + + inline SliceParameter* New() const { return New(NULL); } + + SliceParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SliceParameter& from); + void MergeFrom(const SliceParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SliceParameter* other); + void UnsafeMergeFrom(const SliceParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 axis = 3 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 3; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // repeated uint32 slice_point = 2; + int slice_point_size() const; + void clear_slice_point(); + static const int kSlicePointFieldNumber = 2; + ::google::protobuf::uint32 slice_point(int index) const; + void set_slice_point(int index, ::google::protobuf::uint32 value); + void add_slice_point(::google::protobuf::uint32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + slice_point() const; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_slice_point(); + + // optional uint32 slice_dim = 1 [default = 1]; + bool has_slice_dim() const; + void clear_slice_dim(); + static const int kSliceDimFieldNumber = 1; + ::google::protobuf::uint32 slice_dim() const; + void set_slice_dim(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:caffe.SliceParameter) + private: + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_slice_dim(); + inline void clear_has_slice_dim(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > slice_point_; + ::google::protobuf::int32 axis_; + ::google::protobuf::uint32 slice_dim_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed SliceParameter_default_instance_; + +// ------------------------------------------------------------------- + +class SoftmaxParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.SoftmaxParameter) */ { + public: + SoftmaxParameter(); + virtual ~SoftmaxParameter(); + + SoftmaxParameter(const SoftmaxParameter& from); + + inline SoftmaxParameter& operator=(const SoftmaxParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SoftmaxParameter& default_instance(); + + static const SoftmaxParameter* internal_default_instance(); + + void Swap(SoftmaxParameter* other); + + // implements Message ---------------------------------------------- + + inline SoftmaxParameter* New() const { return New(NULL); } + + SoftmaxParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SoftmaxParameter& from); + void MergeFrom(const SoftmaxParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SoftmaxParameter* other); + void UnsafeMergeFrom(const SoftmaxParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef SoftmaxParameter_Engine Engine; + static const Engine DEFAULT = + SoftmaxParameter_Engine_DEFAULT; + static const Engine CAFFE = + SoftmaxParameter_Engine_CAFFE; + static const Engine CUDNN = + SoftmaxParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return SoftmaxParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + SoftmaxParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + SoftmaxParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + SoftmaxParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return SoftmaxParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return SoftmaxParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return SoftmaxParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 1; + ::caffe::SoftmaxParameter_Engine engine() const; + void set_engine(::caffe::SoftmaxParameter_Engine value); + + // optional int32 axis = 2 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 2; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.SoftmaxParameter) + private: + inline void set_has_engine(); + inline void clear_has_engine(); + inline void set_has_axis(); + inline void clear_has_axis(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + int engine_; + ::google::protobuf::int32 axis_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed SoftmaxParameter_default_instance_; + +// ------------------------------------------------------------------- + +class TanHParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.TanHParameter) */ { + public: + TanHParameter(); + virtual ~TanHParameter(); + + TanHParameter(const TanHParameter& from); + + inline TanHParameter& operator=(const TanHParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const TanHParameter& default_instance(); + + static const TanHParameter* internal_default_instance(); + + void Swap(TanHParameter* other); + + // implements Message ---------------------------------------------- + + inline TanHParameter* New() const { return New(NULL); } + + TanHParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TanHParameter& from); + void MergeFrom(const TanHParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TanHParameter* other); + void UnsafeMergeFrom(const TanHParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef TanHParameter_Engine Engine; + static const Engine DEFAULT = + TanHParameter_Engine_DEFAULT; + static const Engine CAFFE = + TanHParameter_Engine_CAFFE; + static const Engine CUDNN = + TanHParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return TanHParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + TanHParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + TanHParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + TanHParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return TanHParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return TanHParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return TanHParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 1; + ::caffe::TanHParameter_Engine engine() const; + void set_engine(::caffe::TanHParameter_Engine value); + + // @@protoc_insertion_point(class_scope:caffe.TanHParameter) + private: + inline void set_has_engine(); + inline void clear_has_engine(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + int engine_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed TanHParameter_default_instance_; + +// ------------------------------------------------------------------- + +class TileParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.TileParameter) */ { + public: + TileParameter(); + virtual ~TileParameter(); + + TileParameter(const TileParameter& from); + + inline TileParameter& operator=(const TileParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const TileParameter& default_instance(); + + static const TileParameter* internal_default_instance(); + + void Swap(TileParameter* other); + + // implements Message ---------------------------------------------- + + inline TileParameter* New() const { return New(NULL); } + + TileParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TileParameter& from); + void MergeFrom(const TileParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TileParameter* other); + void UnsafeMergeFrom(const TileParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 axis = 1 [default = 1]; + bool has_axis() const; + void clear_axis(); + static const int kAxisFieldNumber = 1; + ::google::protobuf::int32 axis() const; + void set_axis(::google::protobuf::int32 value); + + // optional int32 tiles = 2; + bool has_tiles() const; + void clear_tiles(); + static const int kTilesFieldNumber = 2; + ::google::protobuf::int32 tiles() const; + void set_tiles(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:caffe.TileParameter) + private: + inline void set_has_axis(); + inline void clear_has_axis(); + inline void set_has_tiles(); + inline void clear_has_tiles(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::int32 tiles_; + ::google::protobuf::int32 axis_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed TileParameter_default_instance_; + +// ------------------------------------------------------------------- + +class ThresholdParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.ThresholdParameter) */ { + public: + ThresholdParameter(); + virtual ~ThresholdParameter(); + + ThresholdParameter(const ThresholdParameter& from); + + inline ThresholdParameter& operator=(const ThresholdParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ThresholdParameter& default_instance(); + + static const ThresholdParameter* internal_default_instance(); + + void Swap(ThresholdParameter* other); + + // implements Message ---------------------------------------------- + + inline ThresholdParameter* New() const { return New(NULL); } + + ThresholdParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ThresholdParameter& from); + void MergeFrom(const ThresholdParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ThresholdParameter* other); + void UnsafeMergeFrom(const ThresholdParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float threshold = 1 [default = 0]; + bool has_threshold() const; + void clear_threshold(); + static const int kThresholdFieldNumber = 1; + float threshold() const; + void set_threshold(float value); + + // @@protoc_insertion_point(class_scope:caffe.ThresholdParameter) + private: + inline void set_has_threshold(); + inline void clear_has_threshold(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float threshold_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed ThresholdParameter_default_instance_; + +// ------------------------------------------------------------------- + +class WindowDataParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.WindowDataParameter) */ { + public: + WindowDataParameter(); + virtual ~WindowDataParameter(); + + WindowDataParameter(const WindowDataParameter& from); + + inline WindowDataParameter& operator=(const WindowDataParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const WindowDataParameter& default_instance(); + + static const WindowDataParameter* internal_default_instance(); + + void Swap(WindowDataParameter* other); + + // implements Message ---------------------------------------------- + + inline WindowDataParameter* New() const { return New(NULL); } + + WindowDataParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const WindowDataParameter& from); + void MergeFrom(const WindowDataParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(WindowDataParameter* other); + void UnsafeMergeFrom(const WindowDataParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string source = 1; + bool has_source() const; + void clear_source(); + static const int kSourceFieldNumber = 1; + const ::std::string& source() const; + void set_source(const ::std::string& value); + void set_source(const char* value); + void set_source(const char* value, size_t size); + ::std::string* mutable_source(); + ::std::string* release_source(); + void set_allocated_source(::std::string* source); + + // optional float scale = 2 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 2; + float scale() const; + void set_scale(float value); + + // optional string mean_file = 3; + bool has_mean_file() const; + void clear_mean_file(); + static const int kMeanFileFieldNumber = 3; + const ::std::string& mean_file() const; + void set_mean_file(const ::std::string& value); + void set_mean_file(const char* value); + void set_mean_file(const char* value, size_t size); + ::std::string* mutable_mean_file(); + ::std::string* release_mean_file(); + void set_allocated_mean_file(::std::string* mean_file); + + // optional uint32 batch_size = 4; + bool has_batch_size() const; + void clear_batch_size(); + static const int kBatchSizeFieldNumber = 4; + ::google::protobuf::uint32 batch_size() const; + void set_batch_size(::google::protobuf::uint32 value); + + // optional uint32 crop_size = 5 [default = 0]; + bool has_crop_size() const; + void clear_crop_size(); + static const int kCropSizeFieldNumber = 5; + ::google::protobuf::uint32 crop_size() const; + void set_crop_size(::google::protobuf::uint32 value); + + // optional bool mirror = 6 [default = false]; + bool has_mirror() const; + void clear_mirror(); + static const int kMirrorFieldNumber = 6; + bool mirror() const; + void set_mirror(bool value); + + // optional float fg_threshold = 7 [default = 0.5]; + bool has_fg_threshold() const; + void clear_fg_threshold(); + static const int kFgThresholdFieldNumber = 7; + float fg_threshold() const; + void set_fg_threshold(float value); + + // optional float bg_threshold = 8 [default = 0.5]; + bool has_bg_threshold() const; + void clear_bg_threshold(); + static const int kBgThresholdFieldNumber = 8; + float bg_threshold() const; + void set_bg_threshold(float value); + + // optional float fg_fraction = 9 [default = 0.25]; + bool has_fg_fraction() const; + void clear_fg_fraction(); + static const int kFgFractionFieldNumber = 9; + float fg_fraction() const; + void set_fg_fraction(float value); + + // optional uint32 context_pad = 10 [default = 0]; + bool has_context_pad() const; + void clear_context_pad(); + static const int kContextPadFieldNumber = 10; + ::google::protobuf::uint32 context_pad() const; + void set_context_pad(::google::protobuf::uint32 value); + + // optional string crop_mode = 11 [default = "warp"]; + bool has_crop_mode() const; + void clear_crop_mode(); + static const int kCropModeFieldNumber = 11; + const ::std::string& crop_mode() const; + void set_crop_mode(const ::std::string& value); + void set_crop_mode(const char* value); + void set_crop_mode(const char* value, size_t size); + ::std::string* mutable_crop_mode(); + ::std::string* release_crop_mode(); + void set_allocated_crop_mode(::std::string* crop_mode); + + // optional bool cache_images = 12 [default = false]; + bool has_cache_images() const; + void clear_cache_images(); + static const int kCacheImagesFieldNumber = 12; + bool cache_images() const; + void set_cache_images(bool value); + + // optional string root_folder = 13 [default = ""]; + bool has_root_folder() const; + void clear_root_folder(); + static const int kRootFolderFieldNumber = 13; + const ::std::string& root_folder() const; + void set_root_folder(const ::std::string& value); + void set_root_folder(const char* value); + void set_root_folder(const char* value, size_t size); + ::std::string* mutable_root_folder(); + ::std::string* release_root_folder(); + void set_allocated_root_folder(::std::string* root_folder); + + // @@protoc_insertion_point(class_scope:caffe.WindowDataParameter) + private: + inline void set_has_source(); + inline void clear_has_source(); + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_mean_file(); + inline void clear_has_mean_file(); + inline void set_has_batch_size(); + inline void clear_has_batch_size(); + inline void set_has_crop_size(); + inline void clear_has_crop_size(); + inline void set_has_mirror(); + inline void clear_has_mirror(); + inline void set_has_fg_threshold(); + inline void clear_has_fg_threshold(); + inline void set_has_bg_threshold(); + inline void clear_has_bg_threshold(); + inline void set_has_fg_fraction(); + inline void clear_has_fg_fraction(); + inline void set_has_context_pad(); + inline void clear_has_context_pad(); + inline void set_has_crop_mode(); + inline void clear_has_crop_mode(); + inline void set_has_cache_images(); + inline void clear_has_cache_images(); + inline void set_has_root_folder(); + inline void clear_has_root_folder(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::internal::ArenaStringPtr source_; + ::google::protobuf::internal::ArenaStringPtr mean_file_; + static ::std::string* _default_crop_mode_; + ::google::protobuf::internal::ArenaStringPtr crop_mode_; + ::google::protobuf::internal::ArenaStringPtr root_folder_; + ::google::protobuf::uint32 batch_size_; + ::google::protobuf::uint32 crop_size_; + bool mirror_; + bool cache_images_; + ::google::protobuf::uint32 context_pad_; + float scale_; + float fg_threshold_; + float bg_threshold_; + float fg_fraction_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed WindowDataParameter_default_instance_; + +// ------------------------------------------------------------------- + +class SPPParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.SPPParameter) */ { + public: + SPPParameter(); + virtual ~SPPParameter(); + + SPPParameter(const SPPParameter& from); + + inline SPPParameter& operator=(const SPPParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SPPParameter& default_instance(); + + static const SPPParameter* internal_default_instance(); + + void Swap(SPPParameter* other); + + // implements Message ---------------------------------------------- + + inline SPPParameter* New() const { return New(NULL); } + + SPPParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SPPParameter& from); + void MergeFrom(const SPPParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SPPParameter* other); + void UnsafeMergeFrom(const SPPParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef SPPParameter_PoolMethod PoolMethod; + static const PoolMethod MAX = + SPPParameter_PoolMethod_MAX; + static const PoolMethod AVE = + SPPParameter_PoolMethod_AVE; + static const PoolMethod STOCHASTIC = + SPPParameter_PoolMethod_STOCHASTIC; + static inline bool PoolMethod_IsValid(int value) { + return SPPParameter_PoolMethod_IsValid(value); + } + static const PoolMethod PoolMethod_MIN = + SPPParameter_PoolMethod_PoolMethod_MIN; + static const PoolMethod PoolMethod_MAX = + SPPParameter_PoolMethod_PoolMethod_MAX; + static const int PoolMethod_ARRAYSIZE = + SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + PoolMethod_descriptor() { + return SPPParameter_PoolMethod_descriptor(); + } + static inline const ::std::string& PoolMethod_Name(PoolMethod value) { + return SPPParameter_PoolMethod_Name(value); + } + static inline bool PoolMethod_Parse(const ::std::string& name, + PoolMethod* value) { + return SPPParameter_PoolMethod_Parse(name, value); + } + + typedef SPPParameter_Engine Engine; + static const Engine DEFAULT = + SPPParameter_Engine_DEFAULT; + static const Engine CAFFE = + SPPParameter_Engine_CAFFE; + static const Engine CUDNN = + SPPParameter_Engine_CUDNN; + static inline bool Engine_IsValid(int value) { + return SPPParameter_Engine_IsValid(value); + } + static const Engine Engine_MIN = + SPPParameter_Engine_Engine_MIN; + static const Engine Engine_MAX = + SPPParameter_Engine_Engine_MAX; + static const int Engine_ARRAYSIZE = + SPPParameter_Engine_Engine_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Engine_descriptor() { + return SPPParameter_Engine_descriptor(); + } + static inline const ::std::string& Engine_Name(Engine value) { + return SPPParameter_Engine_Name(value); + } + static inline bool Engine_Parse(const ::std::string& name, + Engine* value) { + return SPPParameter_Engine_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional uint32 pyramid_height = 1; + bool has_pyramid_height() const; + void clear_pyramid_height(); + static const int kPyramidHeightFieldNumber = 1; + ::google::protobuf::uint32 pyramid_height() const; + void set_pyramid_height(::google::protobuf::uint32 value); + + // optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; + bool has_pool() const; + void clear_pool(); + static const int kPoolFieldNumber = 2; + ::caffe::SPPParameter_PoolMethod pool() const; + void set_pool(::caffe::SPPParameter_PoolMethod value); + + // optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; + bool has_engine() const; + void clear_engine(); + static const int kEngineFieldNumber = 6; + ::caffe::SPPParameter_Engine engine() const; + void set_engine(::caffe::SPPParameter_Engine value); + + // @@protoc_insertion_point(class_scope:caffe.SPPParameter) + private: + inline void set_has_pyramid_height(); + inline void clear_has_pyramid_height(); + inline void set_has_pool(); + inline void clear_has_pool(); + inline void set_has_engine(); + inline void clear_has_engine(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::google::protobuf::uint32 pyramid_height_; + int pool_; + int engine_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed SPPParameter_default_instance_; + +// ------------------------------------------------------------------- + +class V1LayerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.V1LayerParameter) */ { + public: + V1LayerParameter(); + virtual ~V1LayerParameter(); + + V1LayerParameter(const V1LayerParameter& from); + + inline V1LayerParameter& operator=(const V1LayerParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const V1LayerParameter& default_instance(); + + static const V1LayerParameter* internal_default_instance(); + + void Swap(V1LayerParameter* other); + + // implements Message ---------------------------------------------- + + inline V1LayerParameter* New() const { return New(NULL); } + + V1LayerParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const V1LayerParameter& from); + void MergeFrom(const V1LayerParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(V1LayerParameter* other); + void UnsafeMergeFrom(const V1LayerParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef V1LayerParameter_LayerType LayerType; + static const LayerType NONE = + V1LayerParameter_LayerType_NONE; + static const LayerType ABSVAL = + V1LayerParameter_LayerType_ABSVAL; + static const LayerType ACCURACY = + V1LayerParameter_LayerType_ACCURACY; + static const LayerType ARGMAX = + V1LayerParameter_LayerType_ARGMAX; + static const LayerType BNLL = + V1LayerParameter_LayerType_BNLL; + static const LayerType CONCAT = + V1LayerParameter_LayerType_CONCAT; + static const LayerType CONTRASTIVE_LOSS = + V1LayerParameter_LayerType_CONTRASTIVE_LOSS; + static const LayerType CONVOLUTION = + V1LayerParameter_LayerType_CONVOLUTION; + static const LayerType DATA = + V1LayerParameter_LayerType_DATA; + static const LayerType DECONVOLUTION = + V1LayerParameter_LayerType_DECONVOLUTION; + static const LayerType DROPOUT = + V1LayerParameter_LayerType_DROPOUT; + static const LayerType DUMMY_DATA = + V1LayerParameter_LayerType_DUMMY_DATA; + static const LayerType EUCLIDEAN_LOSS = + V1LayerParameter_LayerType_EUCLIDEAN_LOSS; + static const LayerType ELTWISE = + V1LayerParameter_LayerType_ELTWISE; + static const LayerType EXP = + V1LayerParameter_LayerType_EXP; + static const LayerType FLATTEN = + V1LayerParameter_LayerType_FLATTEN; + static const LayerType HDF5_DATA = + V1LayerParameter_LayerType_HDF5_DATA; + static const LayerType HDF5_OUTPUT = + V1LayerParameter_LayerType_HDF5_OUTPUT; + static const LayerType HINGE_LOSS = + V1LayerParameter_LayerType_HINGE_LOSS; + static const LayerType IM2COL = + V1LayerParameter_LayerType_IM2COL; + static const LayerType IMAGE_DATA = + V1LayerParameter_LayerType_IMAGE_DATA; + static const LayerType INFOGAIN_LOSS = + V1LayerParameter_LayerType_INFOGAIN_LOSS; + static const LayerType INNER_PRODUCT = + V1LayerParameter_LayerType_INNER_PRODUCT; + static const LayerType LRN = + V1LayerParameter_LayerType_LRN; + static const LayerType MEMORY_DATA = + V1LayerParameter_LayerType_MEMORY_DATA; + static const LayerType MULTINOMIAL_LOGISTIC_LOSS = + V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS; + static const LayerType MVN = + V1LayerParameter_LayerType_MVN; + static const LayerType POOLING = + V1LayerParameter_LayerType_POOLING; + static const LayerType POWER = + V1LayerParameter_LayerType_POWER; + static const LayerType RELU = + V1LayerParameter_LayerType_RELU; + static const LayerType SIGMOID = + V1LayerParameter_LayerType_SIGMOID; + static const LayerType SIGMOID_CROSS_ENTROPY_LOSS = + V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS; + static const LayerType SILENCE = + V1LayerParameter_LayerType_SILENCE; + static const LayerType SOFTMAX = + V1LayerParameter_LayerType_SOFTMAX; + static const LayerType SOFTMAX_LOSS = + V1LayerParameter_LayerType_SOFTMAX_LOSS; + static const LayerType SPLIT = + V1LayerParameter_LayerType_SPLIT; + static const LayerType SLICE = + V1LayerParameter_LayerType_SLICE; + static const LayerType TANH = + V1LayerParameter_LayerType_TANH; + static const LayerType WINDOW_DATA = + V1LayerParameter_LayerType_WINDOW_DATA; + static const LayerType THRESHOLD = + V1LayerParameter_LayerType_THRESHOLD; + static inline bool LayerType_IsValid(int value) { + return V1LayerParameter_LayerType_IsValid(value); + } + static const LayerType LayerType_MIN = + V1LayerParameter_LayerType_LayerType_MIN; + static const LayerType LayerType_MAX = + V1LayerParameter_LayerType_LayerType_MAX; + static const int LayerType_ARRAYSIZE = + V1LayerParameter_LayerType_LayerType_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + LayerType_descriptor() { + return V1LayerParameter_LayerType_descriptor(); + } + static inline const ::std::string& LayerType_Name(LayerType value) { + return V1LayerParameter_LayerType_Name(value); + } + static inline bool LayerType_Parse(const ::std::string& name, + LayerType* value) { + return V1LayerParameter_LayerType_Parse(name, value); + } + + typedef V1LayerParameter_DimCheckMode DimCheckMode; + static const DimCheckMode STRICT = + V1LayerParameter_DimCheckMode_STRICT; + static const DimCheckMode PERMISSIVE = + V1LayerParameter_DimCheckMode_PERMISSIVE; + static inline bool DimCheckMode_IsValid(int value) { + return V1LayerParameter_DimCheckMode_IsValid(value); + } + static const DimCheckMode DimCheckMode_MIN = + V1LayerParameter_DimCheckMode_DimCheckMode_MIN; + static const DimCheckMode DimCheckMode_MAX = + V1LayerParameter_DimCheckMode_DimCheckMode_MAX; + static const int DimCheckMode_ARRAYSIZE = + V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + DimCheckMode_descriptor() { + return V1LayerParameter_DimCheckMode_descriptor(); + } + static inline const ::std::string& DimCheckMode_Name(DimCheckMode value) { + return V1LayerParameter_DimCheckMode_Name(value); + } + static inline bool DimCheckMode_Parse(const ::std::string& name, + DimCheckMode* value) { + return V1LayerParameter_DimCheckMode_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // repeated string bottom = 2; + int bottom_size() const; + void clear_bottom(); + static const int kBottomFieldNumber = 2; + const ::std::string& bottom(int index) const; + ::std::string* mutable_bottom(int index); + void set_bottom(int index, const ::std::string& value); + void set_bottom(int index, const char* value); + void set_bottom(int index, const char* value, size_t size); + ::std::string* add_bottom(); + void add_bottom(const ::std::string& value); + void add_bottom(const char* value); + void add_bottom(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& bottom() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_bottom(); + + // repeated string top = 3; + int top_size() const; + void clear_top(); + static const int kTopFieldNumber = 3; + const ::std::string& top(int index) const; + ::std::string* mutable_top(int index); + void set_top(int index, const ::std::string& value); + void set_top(int index, const char* value); + void set_top(int index, const char* value, size_t size); + ::std::string* add_top(); + void add_top(const ::std::string& value); + void add_top(const char* value); + void add_top(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& top() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_top(); + + // optional string name = 4; + bool has_name() const; + void clear_name(); + static const int kNameFieldNumber = 4; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + + // repeated .caffe.NetStateRule include = 32; + int include_size() const; + void clear_include(); + static const int kIncludeFieldNumber = 32; + const ::caffe::NetStateRule& include(int index) const; + ::caffe::NetStateRule* mutable_include(int index); + ::caffe::NetStateRule* add_include(); + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* + mutable_include(); + const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& + include() const; + + // repeated .caffe.NetStateRule exclude = 33; + int exclude_size() const; + void clear_exclude(); + static const int kExcludeFieldNumber = 33; + const ::caffe::NetStateRule& exclude(int index) const; + ::caffe::NetStateRule* mutable_exclude(int index); + ::caffe::NetStateRule* add_exclude(); + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* + mutable_exclude(); + const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& + exclude() const; + + // optional .caffe.V1LayerParameter.LayerType type = 5; + bool has_type() const; + void clear_type(); + static const int kTypeFieldNumber = 5; + ::caffe::V1LayerParameter_LayerType type() const; + void set_type(::caffe::V1LayerParameter_LayerType value); + + // repeated .caffe.BlobProto blobs = 6; + int blobs_size() const; + void clear_blobs(); + static const int kBlobsFieldNumber = 6; + const ::caffe::BlobProto& blobs(int index) const; + ::caffe::BlobProto* mutable_blobs(int index); + ::caffe::BlobProto* add_blobs(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* + mutable_blobs(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& + blobs() const; + + // repeated string param = 1001; + int param_size() const; + void clear_param(); + static const int kParamFieldNumber = 1001; + const ::std::string& param(int index) const; + ::std::string* mutable_param(int index); + void set_param(int index, const ::std::string& value); + void set_param(int index, const char* value); + void set_param(int index, const char* value, size_t size); + ::std::string* add_param(); + void add_param(const ::std::string& value); + void add_param(const char* value); + void add_param(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& param() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_param(); + + // repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; + int blob_share_mode_size() const; + void clear_blob_share_mode(); + static const int kBlobShareModeFieldNumber = 1002; + ::caffe::V1LayerParameter_DimCheckMode blob_share_mode(int index) const; + void set_blob_share_mode(int index, ::caffe::V1LayerParameter_DimCheckMode value); + void add_blob_share_mode(::caffe::V1LayerParameter_DimCheckMode value); + const ::google::protobuf::RepeatedField& blob_share_mode() const; + ::google::protobuf::RepeatedField* mutable_blob_share_mode(); + + // repeated float blobs_lr = 7; + int blobs_lr_size() const; + void clear_blobs_lr(); + static const int kBlobsLrFieldNumber = 7; + float blobs_lr(int index) const; + void set_blobs_lr(int index, float value); + void add_blobs_lr(float value); + const ::google::protobuf::RepeatedField< float >& + blobs_lr() const; + ::google::protobuf::RepeatedField< float >* + mutable_blobs_lr(); + + // repeated float weight_decay = 8; + int weight_decay_size() const; + void clear_weight_decay(); + static const int kWeightDecayFieldNumber = 8; + float weight_decay(int index) const; + void set_weight_decay(int index, float value); + void add_weight_decay(float value); + const ::google::protobuf::RepeatedField< float >& + weight_decay() const; + ::google::protobuf::RepeatedField< float >* + mutable_weight_decay(); + + // repeated float loss_weight = 35; + int loss_weight_size() const; + void clear_loss_weight(); + static const int kLossWeightFieldNumber = 35; + float loss_weight(int index) const; + void set_loss_weight(int index, float value); + void add_loss_weight(float value); + const ::google::protobuf::RepeatedField< float >& + loss_weight() const; + ::google::protobuf::RepeatedField< float >* + mutable_loss_weight(); + + // optional .caffe.AccuracyParameter accuracy_param = 27; + bool has_accuracy_param() const; + void clear_accuracy_param(); + static const int kAccuracyParamFieldNumber = 27; + const ::caffe::AccuracyParameter& accuracy_param() const; + ::caffe::AccuracyParameter* mutable_accuracy_param(); + ::caffe::AccuracyParameter* release_accuracy_param(); + void set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param); + + // optional .caffe.ArgMaxParameter argmax_param = 23; + bool has_argmax_param() const; + void clear_argmax_param(); + static const int kArgmaxParamFieldNumber = 23; + const ::caffe::ArgMaxParameter& argmax_param() const; + ::caffe::ArgMaxParameter* mutable_argmax_param(); + ::caffe::ArgMaxParameter* release_argmax_param(); + void set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param); + + // optional .caffe.ConcatParameter concat_param = 9; + bool has_concat_param() const; + void clear_concat_param(); + static const int kConcatParamFieldNumber = 9; + const ::caffe::ConcatParameter& concat_param() const; + ::caffe::ConcatParameter* mutable_concat_param(); + ::caffe::ConcatParameter* release_concat_param(); + void set_allocated_concat_param(::caffe::ConcatParameter* concat_param); + + // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40; + bool has_contrastive_loss_param() const; + void clear_contrastive_loss_param(); + static const int kContrastiveLossParamFieldNumber = 40; + const ::caffe::ContrastiveLossParameter& contrastive_loss_param() const; + ::caffe::ContrastiveLossParameter* mutable_contrastive_loss_param(); + ::caffe::ContrastiveLossParameter* release_contrastive_loss_param(); + void set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param); + + // optional .caffe.ConvolutionParameter convolution_param = 10; + bool has_convolution_param() const; + void clear_convolution_param(); + static const int kConvolutionParamFieldNumber = 10; + const ::caffe::ConvolutionParameter& convolution_param() const; + ::caffe::ConvolutionParameter* mutable_convolution_param(); + ::caffe::ConvolutionParameter* release_convolution_param(); + void set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param); + + // optional .caffe.DataParameter data_param = 11; + bool has_data_param() const; + void clear_data_param(); + static const int kDataParamFieldNumber = 11; + const ::caffe::DataParameter& data_param() const; + ::caffe::DataParameter* mutable_data_param(); + ::caffe::DataParameter* release_data_param(); + void set_allocated_data_param(::caffe::DataParameter* data_param); + + // optional .caffe.DropoutParameter dropout_param = 12; + bool has_dropout_param() const; + void clear_dropout_param(); + static const int kDropoutParamFieldNumber = 12; + const ::caffe::DropoutParameter& dropout_param() const; + ::caffe::DropoutParameter* mutable_dropout_param(); + ::caffe::DropoutParameter* release_dropout_param(); + void set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param); + + // optional .caffe.DummyDataParameter dummy_data_param = 26; + bool has_dummy_data_param() const; + void clear_dummy_data_param(); + static const int kDummyDataParamFieldNumber = 26; + const ::caffe::DummyDataParameter& dummy_data_param() const; + ::caffe::DummyDataParameter* mutable_dummy_data_param(); + ::caffe::DummyDataParameter* release_dummy_data_param(); + void set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param); + + // optional .caffe.EltwiseParameter eltwise_param = 24; + bool has_eltwise_param() const; + void clear_eltwise_param(); + static const int kEltwiseParamFieldNumber = 24; + const ::caffe::EltwiseParameter& eltwise_param() const; + ::caffe::EltwiseParameter* mutable_eltwise_param(); + ::caffe::EltwiseParameter* release_eltwise_param(); + void set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param); + + // optional .caffe.ExpParameter exp_param = 41; + bool has_exp_param() const; + void clear_exp_param(); + static const int kExpParamFieldNumber = 41; + const ::caffe::ExpParameter& exp_param() const; + ::caffe::ExpParameter* mutable_exp_param(); + ::caffe::ExpParameter* release_exp_param(); + void set_allocated_exp_param(::caffe::ExpParameter* exp_param); + + // optional .caffe.HDF5DataParameter hdf5_data_param = 13; + bool has_hdf5_data_param() const; + void clear_hdf5_data_param(); + static const int kHdf5DataParamFieldNumber = 13; + const ::caffe::HDF5DataParameter& hdf5_data_param() const; + ::caffe::HDF5DataParameter* mutable_hdf5_data_param(); + ::caffe::HDF5DataParameter* release_hdf5_data_param(); + void set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param); + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 14; + bool has_hdf5_output_param() const; + void clear_hdf5_output_param(); + static const int kHdf5OutputParamFieldNumber = 14; + const ::caffe::HDF5OutputParameter& hdf5_output_param() const; + ::caffe::HDF5OutputParameter* mutable_hdf5_output_param(); + ::caffe::HDF5OutputParameter* release_hdf5_output_param(); + void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param); + + // optional .caffe.HingeLossParameter hinge_loss_param = 29; + bool has_hinge_loss_param() const; + void clear_hinge_loss_param(); + static const int kHingeLossParamFieldNumber = 29; + const ::caffe::HingeLossParameter& hinge_loss_param() const; + ::caffe::HingeLossParameter* mutable_hinge_loss_param(); + ::caffe::HingeLossParameter* release_hinge_loss_param(); + void set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param); + + // optional .caffe.ImageDataParameter image_data_param = 15; + bool has_image_data_param() const; + void clear_image_data_param(); + static const int kImageDataParamFieldNumber = 15; + const ::caffe::ImageDataParameter& image_data_param() const; + ::caffe::ImageDataParameter* mutable_image_data_param(); + ::caffe::ImageDataParameter* release_image_data_param(); + void set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param); + + // optional .caffe.InfogainLossParameter infogain_loss_param = 16; + bool has_infogain_loss_param() const; + void clear_infogain_loss_param(); + static const int kInfogainLossParamFieldNumber = 16; + const ::caffe::InfogainLossParameter& infogain_loss_param() const; + ::caffe::InfogainLossParameter* mutable_infogain_loss_param(); + ::caffe::InfogainLossParameter* release_infogain_loss_param(); + void set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param); + + // optional .caffe.InnerProductParameter inner_product_param = 17; + bool has_inner_product_param() const; + void clear_inner_product_param(); + static const int kInnerProductParamFieldNumber = 17; + const ::caffe::InnerProductParameter& inner_product_param() const; + ::caffe::InnerProductParameter* mutable_inner_product_param(); + ::caffe::InnerProductParameter* release_inner_product_param(); + void set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param); + + // optional .caffe.LRNParameter lrn_param = 18; + bool has_lrn_param() const; + void clear_lrn_param(); + static const int kLrnParamFieldNumber = 18; + const ::caffe::LRNParameter& lrn_param() const; + ::caffe::LRNParameter* mutable_lrn_param(); + ::caffe::LRNParameter* release_lrn_param(); + void set_allocated_lrn_param(::caffe::LRNParameter* lrn_param); + + // optional .caffe.MemoryDataParameter memory_data_param = 22; + bool has_memory_data_param() const; + void clear_memory_data_param(); + static const int kMemoryDataParamFieldNumber = 22; + const ::caffe::MemoryDataParameter& memory_data_param() const; + ::caffe::MemoryDataParameter* mutable_memory_data_param(); + ::caffe::MemoryDataParameter* release_memory_data_param(); + void set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param); + + // optional .caffe.MVNParameter mvn_param = 34; + bool has_mvn_param() const; + void clear_mvn_param(); + static const int kMvnParamFieldNumber = 34; + const ::caffe::MVNParameter& mvn_param() const; + ::caffe::MVNParameter* mutable_mvn_param(); + ::caffe::MVNParameter* release_mvn_param(); + void set_allocated_mvn_param(::caffe::MVNParameter* mvn_param); + + // optional .caffe.PoolingParameter pooling_param = 19; + bool has_pooling_param() const; + void clear_pooling_param(); + static const int kPoolingParamFieldNumber = 19; + const ::caffe::PoolingParameter& pooling_param() const; + ::caffe::PoolingParameter* mutable_pooling_param(); + ::caffe::PoolingParameter* release_pooling_param(); + void set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param); + + // optional .caffe.PowerParameter power_param = 21; + bool has_power_param() const; + void clear_power_param(); + static const int kPowerParamFieldNumber = 21; + const ::caffe::PowerParameter& power_param() const; + ::caffe::PowerParameter* mutable_power_param(); + ::caffe::PowerParameter* release_power_param(); + void set_allocated_power_param(::caffe::PowerParameter* power_param); + + // optional .caffe.ReLUParameter relu_param = 30; + bool has_relu_param() const; + void clear_relu_param(); + static const int kReluParamFieldNumber = 30; + const ::caffe::ReLUParameter& relu_param() const; + ::caffe::ReLUParameter* mutable_relu_param(); + ::caffe::ReLUParameter* release_relu_param(); + void set_allocated_relu_param(::caffe::ReLUParameter* relu_param); + + // optional .caffe.SigmoidParameter sigmoid_param = 38; + bool has_sigmoid_param() const; + void clear_sigmoid_param(); + static const int kSigmoidParamFieldNumber = 38; + const ::caffe::SigmoidParameter& sigmoid_param() const; + ::caffe::SigmoidParameter* mutable_sigmoid_param(); + ::caffe::SigmoidParameter* release_sigmoid_param(); + void set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param); + + // optional .caffe.SoftmaxParameter softmax_param = 39; + bool has_softmax_param() const; + void clear_softmax_param(); + static const int kSoftmaxParamFieldNumber = 39; + const ::caffe::SoftmaxParameter& softmax_param() const; + ::caffe::SoftmaxParameter* mutable_softmax_param(); + ::caffe::SoftmaxParameter* release_softmax_param(); + void set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param); + + // optional .caffe.SliceParameter slice_param = 31; + bool has_slice_param() const; + void clear_slice_param(); + static const int kSliceParamFieldNumber = 31; + const ::caffe::SliceParameter& slice_param() const; + ::caffe::SliceParameter* mutable_slice_param(); + ::caffe::SliceParameter* release_slice_param(); + void set_allocated_slice_param(::caffe::SliceParameter* slice_param); + + // optional .caffe.TanHParameter tanh_param = 37; + bool has_tanh_param() const; + void clear_tanh_param(); + static const int kTanhParamFieldNumber = 37; + const ::caffe::TanHParameter& tanh_param() const; + ::caffe::TanHParameter* mutable_tanh_param(); + ::caffe::TanHParameter* release_tanh_param(); + void set_allocated_tanh_param(::caffe::TanHParameter* tanh_param); + + // optional .caffe.ThresholdParameter threshold_param = 25; + bool has_threshold_param() const; + void clear_threshold_param(); + static const int kThresholdParamFieldNumber = 25; + const ::caffe::ThresholdParameter& threshold_param() const; + ::caffe::ThresholdParameter* mutable_threshold_param(); + ::caffe::ThresholdParameter* release_threshold_param(); + void set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param); + + // optional .caffe.WindowDataParameter window_data_param = 20; + bool has_window_data_param() const; + void clear_window_data_param(); + static const int kWindowDataParamFieldNumber = 20; + const ::caffe::WindowDataParameter& window_data_param() const; + ::caffe::WindowDataParameter* mutable_window_data_param(); + ::caffe::WindowDataParameter* release_window_data_param(); + void set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param); + + // optional .caffe.TransformationParameter transform_param = 36; + bool has_transform_param() const; + void clear_transform_param(); + static const int kTransformParamFieldNumber = 36; + const ::caffe::TransformationParameter& transform_param() const; + ::caffe::TransformationParameter* mutable_transform_param(); + ::caffe::TransformationParameter* release_transform_param(); + void set_allocated_transform_param(::caffe::TransformationParameter* transform_param); + + // optional .caffe.LossParameter loss_param = 42; + bool has_loss_param() const; + void clear_loss_param(); + static const int kLossParamFieldNumber = 42; + const ::caffe::LossParameter& loss_param() const; + ::caffe::LossParameter* mutable_loss_param(); + ::caffe::LossParameter* release_loss_param(); + void set_allocated_loss_param(::caffe::LossParameter* loss_param); + + // optional .caffe.V0LayerParameter layer = 1; + bool has_layer() const; + void clear_layer(); + static const int kLayerFieldNumber = 1; + const ::caffe::V0LayerParameter& layer() const; + ::caffe::V0LayerParameter* mutable_layer(); + ::caffe::V0LayerParameter* release_layer(); + void set_allocated_layer(::caffe::V0LayerParameter* layer); + + // @@protoc_insertion_point(class_scope:caffe.V1LayerParameter) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_accuracy_param(); + inline void clear_has_accuracy_param(); + inline void set_has_argmax_param(); + inline void clear_has_argmax_param(); + inline void set_has_concat_param(); + inline void clear_has_concat_param(); + inline void set_has_contrastive_loss_param(); + inline void clear_has_contrastive_loss_param(); + inline void set_has_convolution_param(); + inline void clear_has_convolution_param(); + inline void set_has_data_param(); + inline void clear_has_data_param(); + inline void set_has_dropout_param(); + inline void clear_has_dropout_param(); + inline void set_has_dummy_data_param(); + inline void clear_has_dummy_data_param(); + inline void set_has_eltwise_param(); + inline void clear_has_eltwise_param(); + inline void set_has_exp_param(); + inline void clear_has_exp_param(); + inline void set_has_hdf5_data_param(); + inline void clear_has_hdf5_data_param(); + inline void set_has_hdf5_output_param(); + inline void clear_has_hdf5_output_param(); + inline void set_has_hinge_loss_param(); + inline void clear_has_hinge_loss_param(); + inline void set_has_image_data_param(); + inline void clear_has_image_data_param(); + inline void set_has_infogain_loss_param(); + inline void clear_has_infogain_loss_param(); + inline void set_has_inner_product_param(); + inline void clear_has_inner_product_param(); + inline void set_has_lrn_param(); + inline void clear_has_lrn_param(); + inline void set_has_memory_data_param(); + inline void clear_has_memory_data_param(); + inline void set_has_mvn_param(); + inline void clear_has_mvn_param(); + inline void set_has_pooling_param(); + inline void clear_has_pooling_param(); + inline void set_has_power_param(); + inline void clear_has_power_param(); + inline void set_has_relu_param(); + inline void clear_has_relu_param(); + inline void set_has_sigmoid_param(); + inline void clear_has_sigmoid_param(); + inline void set_has_softmax_param(); + inline void clear_has_softmax_param(); + inline void set_has_slice_param(); + inline void clear_has_slice_param(); + inline void set_has_tanh_param(); + inline void clear_has_tanh_param(); + inline void set_has_threshold_param(); + inline void clear_has_threshold_param(); + inline void set_has_window_data_param(); + inline void clear_has_window_data_param(); + inline void set_has_transform_param(); + inline void clear_has_transform_param(); + inline void set_has_loss_param(); + inline void clear_has_loss_param(); + inline void set_has_layer(); + inline void clear_has_layer(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<2> _has_bits_; + ::google::protobuf::RepeatedPtrField< ::std::string> bottom_; + ::google::protobuf::RepeatedPtrField< ::std::string> top_; + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule > include_; + ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule > exclude_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > blobs_; + ::google::protobuf::RepeatedPtrField< ::std::string> param_; + ::google::protobuf::RepeatedField blob_share_mode_; + ::google::protobuf::RepeatedField< float > blobs_lr_; + ::google::protobuf::RepeatedField< float > weight_decay_; + ::google::protobuf::RepeatedField< float > loss_weight_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::caffe::AccuracyParameter* accuracy_param_; + ::caffe::ArgMaxParameter* argmax_param_; + ::caffe::ConcatParameter* concat_param_; + ::caffe::ContrastiveLossParameter* contrastive_loss_param_; + ::caffe::ConvolutionParameter* convolution_param_; + ::caffe::DataParameter* data_param_; + ::caffe::DropoutParameter* dropout_param_; + ::caffe::DummyDataParameter* dummy_data_param_; + ::caffe::EltwiseParameter* eltwise_param_; + ::caffe::ExpParameter* exp_param_; + ::caffe::HDF5DataParameter* hdf5_data_param_; + ::caffe::HDF5OutputParameter* hdf5_output_param_; + ::caffe::HingeLossParameter* hinge_loss_param_; + ::caffe::ImageDataParameter* image_data_param_; + ::caffe::InfogainLossParameter* infogain_loss_param_; + ::caffe::InnerProductParameter* inner_product_param_; + ::caffe::LRNParameter* lrn_param_; + ::caffe::MemoryDataParameter* memory_data_param_; + ::caffe::MVNParameter* mvn_param_; + ::caffe::PoolingParameter* pooling_param_; + ::caffe::PowerParameter* power_param_; + ::caffe::ReLUParameter* relu_param_; + ::caffe::SigmoidParameter* sigmoid_param_; + ::caffe::SoftmaxParameter* softmax_param_; + ::caffe::SliceParameter* slice_param_; + ::caffe::TanHParameter* tanh_param_; + ::caffe::ThresholdParameter* threshold_param_; + ::caffe::WindowDataParameter* window_data_param_; + ::caffe::TransformationParameter* transform_param_; + ::caffe::LossParameter* loss_param_; + ::caffe::V0LayerParameter* layer_; + int type_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed V1LayerParameter_default_instance_; + +// ------------------------------------------------------------------- + +class V0LayerParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.V0LayerParameter) */ { + public: + V0LayerParameter(); + virtual ~V0LayerParameter(); + + V0LayerParameter(const V0LayerParameter& from); + + inline V0LayerParameter& operator=(const V0LayerParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const V0LayerParameter& default_instance(); + + static const V0LayerParameter* internal_default_instance(); + + void Swap(V0LayerParameter* other); + + // implements Message ---------------------------------------------- + + inline V0LayerParameter* New() const { return New(NULL); } + + V0LayerParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const V0LayerParameter& from); + void MergeFrom(const V0LayerParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(V0LayerParameter* other); + void UnsafeMergeFrom(const V0LayerParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef V0LayerParameter_PoolMethod PoolMethod; + static const PoolMethod MAX = + V0LayerParameter_PoolMethod_MAX; + static const PoolMethod AVE = + V0LayerParameter_PoolMethod_AVE; + static const PoolMethod STOCHASTIC = + V0LayerParameter_PoolMethod_STOCHASTIC; + static inline bool PoolMethod_IsValid(int value) { + return V0LayerParameter_PoolMethod_IsValid(value); + } + static const PoolMethod PoolMethod_MIN = + V0LayerParameter_PoolMethod_PoolMethod_MIN; + static const PoolMethod PoolMethod_MAX = + V0LayerParameter_PoolMethod_PoolMethod_MAX; + static const int PoolMethod_ARRAYSIZE = + V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + PoolMethod_descriptor() { + return V0LayerParameter_PoolMethod_descriptor(); + } + static inline const ::std::string& PoolMethod_Name(PoolMethod value) { + return V0LayerParameter_PoolMethod_Name(value); + } + static inline bool PoolMethod_Parse(const ::std::string& name, + PoolMethod* value) { + return V0LayerParameter_PoolMethod_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional string name = 1; + bool has_name() const; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + + // optional string type = 2; + bool has_type() const; + void clear_type(); + static const int kTypeFieldNumber = 2; + const ::std::string& type() const; + void set_type(const ::std::string& value); + void set_type(const char* value); + void set_type(const char* value, size_t size); + ::std::string* mutable_type(); + ::std::string* release_type(); + void set_allocated_type(::std::string* type); + + // optional uint32 num_output = 3; + bool has_num_output() const; + void clear_num_output(); + static const int kNumOutputFieldNumber = 3; + ::google::protobuf::uint32 num_output() const; + void set_num_output(::google::protobuf::uint32 value); + + // optional bool biasterm = 4 [default = true]; + bool has_biasterm() const; + void clear_biasterm(); + static const int kBiastermFieldNumber = 4; + bool biasterm() const; + void set_biasterm(bool value); + + // optional .caffe.FillerParameter weight_filler = 5; + bool has_weight_filler() const; + void clear_weight_filler(); + static const int kWeightFillerFieldNumber = 5; + const ::caffe::FillerParameter& weight_filler() const; + ::caffe::FillerParameter* mutable_weight_filler(); + ::caffe::FillerParameter* release_weight_filler(); + void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler); + + // optional .caffe.FillerParameter bias_filler = 6; + bool has_bias_filler() const; + void clear_bias_filler(); + static const int kBiasFillerFieldNumber = 6; + const ::caffe::FillerParameter& bias_filler() const; + ::caffe::FillerParameter* mutable_bias_filler(); + ::caffe::FillerParameter* release_bias_filler(); + void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler); + + // optional uint32 pad = 7 [default = 0]; + bool has_pad() const; + void clear_pad(); + static const int kPadFieldNumber = 7; + ::google::protobuf::uint32 pad() const; + void set_pad(::google::protobuf::uint32 value); + + // optional uint32 kernelsize = 8; + bool has_kernelsize() const; + void clear_kernelsize(); + static const int kKernelsizeFieldNumber = 8; + ::google::protobuf::uint32 kernelsize() const; + void set_kernelsize(::google::protobuf::uint32 value); + + // optional uint32 group = 9 [default = 1]; + bool has_group() const; + void clear_group(); + static const int kGroupFieldNumber = 9; + ::google::protobuf::uint32 group() const; + void set_group(::google::protobuf::uint32 value); + + // optional uint32 stride = 10 [default = 1]; + bool has_stride() const; + void clear_stride(); + static const int kStrideFieldNumber = 10; + ::google::protobuf::uint32 stride() const; + void set_stride(::google::protobuf::uint32 value); + + // optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; + bool has_pool() const; + void clear_pool(); + static const int kPoolFieldNumber = 11; + ::caffe::V0LayerParameter_PoolMethod pool() const; + void set_pool(::caffe::V0LayerParameter_PoolMethod value); + + // optional float dropout_ratio = 12 [default = 0.5]; + bool has_dropout_ratio() const; + void clear_dropout_ratio(); + static const int kDropoutRatioFieldNumber = 12; + float dropout_ratio() const; + void set_dropout_ratio(float value); + + // optional uint32 local_size = 13 [default = 5]; + bool has_local_size() const; + void clear_local_size(); + static const int kLocalSizeFieldNumber = 13; + ::google::protobuf::uint32 local_size() const; + void set_local_size(::google::protobuf::uint32 value); + + // optional float alpha = 14 [default = 1]; + bool has_alpha() const; + void clear_alpha(); + static const int kAlphaFieldNumber = 14; + float alpha() const; + void set_alpha(float value); + + // optional float beta = 15 [default = 0.75]; + bool has_beta() const; + void clear_beta(); + static const int kBetaFieldNumber = 15; + float beta() const; + void set_beta(float value); + + // optional float k = 22 [default = 1]; + bool has_k() const; + void clear_k(); + static const int kKFieldNumber = 22; + float k() const; + void set_k(float value); + + // optional string source = 16; + bool has_source() const; + void clear_source(); + static const int kSourceFieldNumber = 16; + const ::std::string& source() const; + void set_source(const ::std::string& value); + void set_source(const char* value); + void set_source(const char* value, size_t size); + ::std::string* mutable_source(); + ::std::string* release_source(); + void set_allocated_source(::std::string* source); + + // optional float scale = 17 [default = 1]; + bool has_scale() const; + void clear_scale(); + static const int kScaleFieldNumber = 17; + float scale() const; + void set_scale(float value); + + // optional string meanfile = 18; + bool has_meanfile() const; + void clear_meanfile(); + static const int kMeanfileFieldNumber = 18; + const ::std::string& meanfile() const; + void set_meanfile(const ::std::string& value); + void set_meanfile(const char* value); + void set_meanfile(const char* value, size_t size); + ::std::string* mutable_meanfile(); + ::std::string* release_meanfile(); + void set_allocated_meanfile(::std::string* meanfile); + + // optional uint32 batchsize = 19; + bool has_batchsize() const; + void clear_batchsize(); + static const int kBatchsizeFieldNumber = 19; + ::google::protobuf::uint32 batchsize() const; + void set_batchsize(::google::protobuf::uint32 value); + + // optional uint32 cropsize = 20 [default = 0]; + bool has_cropsize() const; + void clear_cropsize(); + static const int kCropsizeFieldNumber = 20; + ::google::protobuf::uint32 cropsize() const; + void set_cropsize(::google::protobuf::uint32 value); + + // optional bool mirror = 21 [default = false]; + bool has_mirror() const; + void clear_mirror(); + static const int kMirrorFieldNumber = 21; + bool mirror() const; + void set_mirror(bool value); + + // repeated .caffe.BlobProto blobs = 50; + int blobs_size() const; + void clear_blobs(); + static const int kBlobsFieldNumber = 50; + const ::caffe::BlobProto& blobs(int index) const; + ::caffe::BlobProto* mutable_blobs(int index); + ::caffe::BlobProto* add_blobs(); + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* + mutable_blobs(); + const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& + blobs() const; + + // repeated float blobs_lr = 51; + int blobs_lr_size() const; + void clear_blobs_lr(); + static const int kBlobsLrFieldNumber = 51; + float blobs_lr(int index) const; + void set_blobs_lr(int index, float value); + void add_blobs_lr(float value); + const ::google::protobuf::RepeatedField< float >& + blobs_lr() const; + ::google::protobuf::RepeatedField< float >* + mutable_blobs_lr(); + + // repeated float weight_decay = 52; + int weight_decay_size() const; + void clear_weight_decay(); + static const int kWeightDecayFieldNumber = 52; + float weight_decay(int index) const; + void set_weight_decay(int index, float value); + void add_weight_decay(float value); + const ::google::protobuf::RepeatedField< float >& + weight_decay() const; + ::google::protobuf::RepeatedField< float >* + mutable_weight_decay(); + + // optional uint32 rand_skip = 53 [default = 0]; + bool has_rand_skip() const; + void clear_rand_skip(); + static const int kRandSkipFieldNumber = 53; + ::google::protobuf::uint32 rand_skip() const; + void set_rand_skip(::google::protobuf::uint32 value); + + // optional float det_fg_threshold = 54 [default = 0.5]; + bool has_det_fg_threshold() const; + void clear_det_fg_threshold(); + static const int kDetFgThresholdFieldNumber = 54; + float det_fg_threshold() const; + void set_det_fg_threshold(float value); + + // optional float det_bg_threshold = 55 [default = 0.5]; + bool has_det_bg_threshold() const; + void clear_det_bg_threshold(); + static const int kDetBgThresholdFieldNumber = 55; + float det_bg_threshold() const; + void set_det_bg_threshold(float value); + + // optional float det_fg_fraction = 56 [default = 0.25]; + bool has_det_fg_fraction() const; + void clear_det_fg_fraction(); + static const int kDetFgFractionFieldNumber = 56; + float det_fg_fraction() const; + void set_det_fg_fraction(float value); + + // optional uint32 det_context_pad = 58 [default = 0]; + bool has_det_context_pad() const; + void clear_det_context_pad(); + static const int kDetContextPadFieldNumber = 58; + ::google::protobuf::uint32 det_context_pad() const; + void set_det_context_pad(::google::protobuf::uint32 value); + + // optional string det_crop_mode = 59 [default = "warp"]; + bool has_det_crop_mode() const; + void clear_det_crop_mode(); + static const int kDetCropModeFieldNumber = 59; + const ::std::string& det_crop_mode() const; + void set_det_crop_mode(const ::std::string& value); + void set_det_crop_mode(const char* value); + void set_det_crop_mode(const char* value, size_t size); + ::std::string* mutable_det_crop_mode(); + ::std::string* release_det_crop_mode(); + void set_allocated_det_crop_mode(::std::string* det_crop_mode); + + // optional int32 new_num = 60 [default = 0]; + bool has_new_num() const; + void clear_new_num(); + static const int kNewNumFieldNumber = 60; + ::google::protobuf::int32 new_num() const; + void set_new_num(::google::protobuf::int32 value); + + // optional int32 new_channels = 61 [default = 0]; + bool has_new_channels() const; + void clear_new_channels(); + static const int kNewChannelsFieldNumber = 61; + ::google::protobuf::int32 new_channels() const; + void set_new_channels(::google::protobuf::int32 value); + + // optional int32 new_height = 62 [default = 0]; + bool has_new_height() const; + void clear_new_height(); + static const int kNewHeightFieldNumber = 62; + ::google::protobuf::int32 new_height() const; + void set_new_height(::google::protobuf::int32 value); + + // optional int32 new_width = 63 [default = 0]; + bool has_new_width() const; + void clear_new_width(); + static const int kNewWidthFieldNumber = 63; + ::google::protobuf::int32 new_width() const; + void set_new_width(::google::protobuf::int32 value); + + // optional bool shuffle_images = 64 [default = false]; + bool has_shuffle_images() const; + void clear_shuffle_images(); + static const int kShuffleImagesFieldNumber = 64; + bool shuffle_images() const; + void set_shuffle_images(bool value); + + // optional uint32 concat_dim = 65 [default = 1]; + bool has_concat_dim() const; + void clear_concat_dim(); + static const int kConcatDimFieldNumber = 65; + ::google::protobuf::uint32 concat_dim() const; + void set_concat_dim(::google::protobuf::uint32 value); + + // optional .caffe.HDF5OutputParameter hdf5_output_param = 1001; + bool has_hdf5_output_param() const; + void clear_hdf5_output_param(); + static const int kHdf5OutputParamFieldNumber = 1001; + const ::caffe::HDF5OutputParameter& hdf5_output_param() const; + ::caffe::HDF5OutputParameter* mutable_hdf5_output_param(); + ::caffe::HDF5OutputParameter* release_hdf5_output_param(); + void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param); + + // @@protoc_insertion_point(class_scope:caffe.V0LayerParameter) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_num_output(); + inline void clear_has_num_output(); + inline void set_has_biasterm(); + inline void clear_has_biasterm(); + inline void set_has_weight_filler(); + inline void clear_has_weight_filler(); + inline void set_has_bias_filler(); + inline void clear_has_bias_filler(); + inline void set_has_pad(); + inline void clear_has_pad(); + inline void set_has_kernelsize(); + inline void clear_has_kernelsize(); + inline void set_has_group(); + inline void clear_has_group(); + inline void set_has_stride(); + inline void clear_has_stride(); + inline void set_has_pool(); + inline void clear_has_pool(); + inline void set_has_dropout_ratio(); + inline void clear_has_dropout_ratio(); + inline void set_has_local_size(); + inline void clear_has_local_size(); + inline void set_has_alpha(); + inline void clear_has_alpha(); + inline void set_has_beta(); + inline void clear_has_beta(); + inline void set_has_k(); + inline void clear_has_k(); + inline void set_has_source(); + inline void clear_has_source(); + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_meanfile(); + inline void clear_has_meanfile(); + inline void set_has_batchsize(); + inline void clear_has_batchsize(); + inline void set_has_cropsize(); + inline void clear_has_cropsize(); + inline void set_has_mirror(); + inline void clear_has_mirror(); + inline void set_has_rand_skip(); + inline void clear_has_rand_skip(); + inline void set_has_det_fg_threshold(); + inline void clear_has_det_fg_threshold(); + inline void set_has_det_bg_threshold(); + inline void clear_has_det_bg_threshold(); + inline void set_has_det_fg_fraction(); + inline void clear_has_det_fg_fraction(); + inline void set_has_det_context_pad(); + inline void clear_has_det_context_pad(); + inline void set_has_det_crop_mode(); + inline void clear_has_det_crop_mode(); + inline void set_has_new_num(); + inline void clear_has_new_num(); + inline void set_has_new_channels(); + inline void clear_has_new_channels(); + inline void set_has_new_height(); + inline void clear_has_new_height(); + inline void set_has_new_width(); + inline void clear_has_new_width(); + inline void set_has_shuffle_images(); + inline void clear_has_shuffle_images(); + inline void set_has_concat_dim(); + inline void clear_has_concat_dim(); + inline void set_has_hdf5_output_param(); + inline void clear_has_hdf5_output_param(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<2> _has_bits_; + ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > blobs_; + ::google::protobuf::RepeatedField< float > blobs_lr_; + ::google::protobuf::RepeatedField< float > weight_decay_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::google::protobuf::internal::ArenaStringPtr source_; + ::google::protobuf::internal::ArenaStringPtr meanfile_; + static ::std::string* _default_det_crop_mode_; + ::google::protobuf::internal::ArenaStringPtr det_crop_mode_; + ::caffe::FillerParameter* weight_filler_; + ::caffe::FillerParameter* bias_filler_; + ::caffe::HDF5OutputParameter* hdf5_output_param_; + ::google::protobuf::uint32 num_output_; + ::google::protobuf::uint32 pad_; + ::google::protobuf::uint32 kernelsize_; + int pool_; + ::google::protobuf::uint32 batchsize_; + ::google::protobuf::uint32 cropsize_; + ::google::protobuf::uint32 rand_skip_; + bool mirror_; + bool shuffle_images_; + ::google::protobuf::uint32 det_context_pad_; + ::google::protobuf::int32 new_num_; + ::google::protobuf::int32 new_channels_; + ::google::protobuf::int32 new_height_; + ::google::protobuf::int32 new_width_; + ::google::protobuf::uint32 concat_dim_; + bool biasterm_; + ::google::protobuf::uint32 group_; + ::google::protobuf::uint32 stride_; + float dropout_ratio_; + ::google::protobuf::uint32 local_size_; + float alpha_; + float beta_; + float k_; + float scale_; + float det_fg_threshold_; + float det_bg_threshold_; + float det_fg_fraction_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed V0LayerParameter_default_instance_; + +// ------------------------------------------------------------------- + +class PReLUParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.PReLUParameter) */ { + public: + PReLUParameter(); + virtual ~PReLUParameter(); + + PReLUParameter(const PReLUParameter& from); + + inline PReLUParameter& operator=(const PReLUParameter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PReLUParameter& default_instance(); + + static const PReLUParameter* internal_default_instance(); + + void Swap(PReLUParameter* other); + + // implements Message ---------------------------------------------- + + inline PReLUParameter* New() const { return New(NULL); } + + PReLUParameter* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PReLUParameter& from); + void MergeFrom(const PReLUParameter& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PReLUParameter* other); + void UnsafeMergeFrom(const PReLUParameter& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .caffe.FillerParameter filler = 1; + bool has_filler() const; + void clear_filler(); + static const int kFillerFieldNumber = 1; + const ::caffe::FillerParameter& filler() const; + ::caffe::FillerParameter* mutable_filler(); + ::caffe::FillerParameter* release_filler(); + void set_allocated_filler(::caffe::FillerParameter* filler); + + // optional bool channel_shared = 2 [default = false]; + bool has_channel_shared() const; + void clear_channel_shared(); + static const int kChannelSharedFieldNumber = 2; + bool channel_shared() const; + void set_channel_shared(bool value); + + // @@protoc_insertion_point(class_scope:caffe.PReLUParameter) + private: + inline void set_has_filler(); + inline void clear_has_filler(); + inline void set_has_channel_shared(); + inline void clear_has_channel_shared(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + ::caffe::FillerParameter* filler_; + bool channel_shared_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed PReLUParameter_default_instance_; + +// ------------------------------------------------------------------- + +class NormalizedBBox : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:caffe.NormalizedBBox) */ { + public: + NormalizedBBox(); + virtual ~NormalizedBBox(); + + NormalizedBBox(const NormalizedBBox& from); + + inline NormalizedBBox& operator=(const NormalizedBBox& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NormalizedBBox& default_instance(); + + static const NormalizedBBox* internal_default_instance(); + + void Swap(NormalizedBBox* other); + + // implements Message ---------------------------------------------- + + inline NormalizedBBox* New() const { return New(NULL); } + + NormalizedBBox* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NormalizedBBox& from); + void MergeFrom(const NormalizedBBox& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NormalizedBBox* other); + void UnsafeMergeFrom(const NormalizedBBox& from); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float xmin = 1; + bool has_xmin() const; + void clear_xmin(); + static const int kXminFieldNumber = 1; + float xmin() const; + void set_xmin(float value); + + // optional float ymin = 2; + bool has_ymin() const; + void clear_ymin(); + static const int kYminFieldNumber = 2; + float ymin() const; + void set_ymin(float value); + + // optional float xmax = 3; + bool has_xmax() const; + void clear_xmax(); + static const int kXmaxFieldNumber = 3; + float xmax() const; + void set_xmax(float value); + + // optional float ymax = 4; + bool has_ymax() const; + void clear_ymax(); + static const int kYmaxFieldNumber = 4; + float ymax() const; + void set_ymax(float value); + + // optional int32 label = 5; + bool has_label() const; + void clear_label(); + static const int kLabelFieldNumber = 5; + ::google::protobuf::int32 label() const; + void set_label(::google::protobuf::int32 value); + + // optional bool difficult = 6; + bool has_difficult() const; + void clear_difficult(); + static const int kDifficultFieldNumber = 6; + bool difficult() const; + void set_difficult(bool value); + + // optional float score = 7; + bool has_score() const; + void clear_score(); + static const int kScoreFieldNumber = 7; + float score() const; + void set_score(float value); + + // optional float size = 8; + bool has_size() const; + void clear_size(); + static const int kSizeFieldNumber = 8; + float size() const; + void set_size(float value); + + // @@protoc_insertion_point(class_scope:caffe.NormalizedBBox) + private: + inline void set_has_xmin(); + inline void clear_has_xmin(); + inline void set_has_ymin(); + inline void clear_has_ymin(); + inline void set_has_xmax(); + inline void clear_has_xmax(); + inline void set_has_ymax(); + inline void clear_has_ymax(); + inline void set_has_label(); + inline void clear_has_label(); + inline void set_has_difficult(); + inline void clear_has_difficult(); + inline void set_has_score(); + inline void clear_has_score(); + inline void set_has_size(); + inline void clear_has_size(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable int _cached_size_; + float xmin_; + float ymin_; + float xmax_; + float ymax_; + ::google::protobuf::int32 label_; + bool difficult_; + float score_; + float size_; + friend void protobuf_InitDefaults_caffe_2eproto_impl(); + friend void protobuf_AddDesc_caffe_2eproto_impl(); + friend void protobuf_AssignDesc_caffe_2eproto(); + friend void protobuf_ShutdownFile_caffe_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NormalizedBBox_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// BlobShape + +// repeated int64 dim = 1 [packed = true]; +inline int BlobShape::dim_size() const { + return dim_.size(); +} +inline void BlobShape::clear_dim() { + dim_.Clear(); +} +inline ::google::protobuf::int64 BlobShape::dim(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobShape.dim) + return dim_.Get(index); +} +inline void BlobShape::set_dim(int index, ::google::protobuf::int64 value) { + dim_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobShape.dim) +} +inline void BlobShape::add_dim(::google::protobuf::int64 value) { + dim_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobShape.dim) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& +BlobShape::dim() const { + // @@protoc_insertion_point(field_list:caffe.BlobShape.dim) + return dim_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >* +BlobShape::mutable_dim() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobShape.dim) + return &dim_; +} + +inline const BlobShape* BlobShape::internal_default_instance() { + return &BlobShape_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// BlobProto + +// optional .caffe.BlobShape shape = 7; +inline bool BlobProto::has_shape() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BlobProto::set_has_shape() { + _has_bits_[0] |= 0x00000001u; +} +inline void BlobProto::clear_has_shape() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BlobProto::clear_shape() { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + clear_has_shape(); +} +inline const ::caffe::BlobShape& BlobProto::shape() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.shape) + return shape_ != NULL ? *shape_ + : *::caffe::BlobShape::internal_default_instance(); +} +inline ::caffe::BlobShape* BlobProto::mutable_shape() { + set_has_shape(); + if (shape_ == NULL) { + shape_ = new ::caffe::BlobShape; + } + // @@protoc_insertion_point(field_mutable:caffe.BlobProto.shape) + return shape_; +} +inline ::caffe::BlobShape* BlobProto::release_shape() { + // @@protoc_insertion_point(field_release:caffe.BlobProto.shape) + clear_has_shape(); + ::caffe::BlobShape* temp = shape_; + shape_ = NULL; + return temp; +} +inline void BlobProto::set_allocated_shape(::caffe::BlobShape* shape) { + delete shape_; + shape_ = shape; + if (shape) { + set_has_shape(); + } else { + clear_has_shape(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.BlobProto.shape) +} + +// repeated float data = 5 [packed = true]; +inline int BlobProto::data_size() const { + return data_.size(); +} +inline void BlobProto::clear_data() { + data_.Clear(); +} +inline float BlobProto::data(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.data) + return data_.Get(index); +} +inline void BlobProto::set_data(int index, float value) { + data_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.data) +} +inline void BlobProto::add_data(float value) { + data_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.data) +} +inline const ::google::protobuf::RepeatedField< float >& +BlobProto::data() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.data) + return data_; +} +inline ::google::protobuf::RepeatedField< float >* +BlobProto::mutable_data() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.data) + return &data_; +} + +// repeated float diff = 6 [packed = true]; +inline int BlobProto::diff_size() const { + return diff_.size(); +} +inline void BlobProto::clear_diff() { + diff_.Clear(); +} +inline float BlobProto::diff(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.diff) + return diff_.Get(index); +} +inline void BlobProto::set_diff(int index, float value) { + diff_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.diff) +} +inline void BlobProto::add_diff(float value) { + diff_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.diff) +} +inline const ::google::protobuf::RepeatedField< float >& +BlobProto::diff() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.diff) + return diff_; +} +inline ::google::protobuf::RepeatedField< float >* +BlobProto::mutable_diff() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.diff) + return &diff_; +} + +// repeated double double_data = 8 [packed = true]; +inline int BlobProto::double_data_size() const { + return double_data_.size(); +} +inline void BlobProto::clear_double_data() { + double_data_.Clear(); +} +inline double BlobProto::double_data(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.double_data) + return double_data_.Get(index); +} +inline void BlobProto::set_double_data(int index, double value) { + double_data_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.double_data) +} +inline void BlobProto::add_double_data(double value) { + double_data_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.double_data) +} +inline const ::google::protobuf::RepeatedField< double >& +BlobProto::double_data() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.double_data) + return double_data_; +} +inline ::google::protobuf::RepeatedField< double >* +BlobProto::mutable_double_data() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.double_data) + return &double_data_; +} + +// repeated double double_diff = 9 [packed = true]; +inline int BlobProto::double_diff_size() const { + return double_diff_.size(); +} +inline void BlobProto::clear_double_diff() { + double_diff_.Clear(); +} +inline double BlobProto::double_diff(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.double_diff) + return double_diff_.Get(index); +} +inline void BlobProto::set_double_diff(int index, double value) { + double_diff_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.BlobProto.double_diff) +} +inline void BlobProto::add_double_diff(double value) { + double_diff_.Add(value); + // @@protoc_insertion_point(field_add:caffe.BlobProto.double_diff) +} +inline const ::google::protobuf::RepeatedField< double >& +BlobProto::double_diff() const { + // @@protoc_insertion_point(field_list:caffe.BlobProto.double_diff) + return double_diff_; +} +inline ::google::protobuf::RepeatedField< double >* +BlobProto::mutable_double_diff() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProto.double_diff) + return &double_diff_; +} + +// optional int32 num = 1 [default = 0]; +inline bool BlobProto::has_num() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void BlobProto::set_has_num() { + _has_bits_[0] |= 0x00000020u; +} +inline void BlobProto::clear_has_num() { + _has_bits_[0] &= ~0x00000020u; +} +inline void BlobProto::clear_num() { + num_ = 0; + clear_has_num(); +} +inline ::google::protobuf::int32 BlobProto::num() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.num) + return num_; +} +inline void BlobProto::set_num(::google::protobuf::int32 value) { + set_has_num(); + num_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.num) +} + +// optional int32 channels = 2 [default = 0]; +inline bool BlobProto::has_channels() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void BlobProto::set_has_channels() { + _has_bits_[0] |= 0x00000040u; +} +inline void BlobProto::clear_has_channels() { + _has_bits_[0] &= ~0x00000040u; +} +inline void BlobProto::clear_channels() { + channels_ = 0; + clear_has_channels(); +} +inline ::google::protobuf::int32 BlobProto::channels() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.channels) + return channels_; +} +inline void BlobProto::set_channels(::google::protobuf::int32 value) { + set_has_channels(); + channels_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.channels) +} + +// optional int32 height = 3 [default = 0]; +inline bool BlobProto::has_height() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void BlobProto::set_has_height() { + _has_bits_[0] |= 0x00000080u; +} +inline void BlobProto::clear_has_height() { + _has_bits_[0] &= ~0x00000080u; +} +inline void BlobProto::clear_height() { + height_ = 0; + clear_has_height(); +} +inline ::google::protobuf::int32 BlobProto::height() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.height) + return height_; +} +inline void BlobProto::set_height(::google::protobuf::int32 value) { + set_has_height(); + height_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.height) +} + +// optional int32 width = 4 [default = 0]; +inline bool BlobProto::has_width() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void BlobProto::set_has_width() { + _has_bits_[0] |= 0x00000100u; +} +inline void BlobProto::clear_has_width() { + _has_bits_[0] &= ~0x00000100u; +} +inline void BlobProto::clear_width() { + width_ = 0; + clear_has_width(); +} +inline ::google::protobuf::int32 BlobProto::width() const { + // @@protoc_insertion_point(field_get:caffe.BlobProto.width) + return width_; +} +inline void BlobProto::set_width(::google::protobuf::int32 value) { + set_has_width(); + width_ = value; + // @@protoc_insertion_point(field_set:caffe.BlobProto.width) +} + +inline const BlobProto* BlobProto::internal_default_instance() { + return &BlobProto_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// BlobProtoVector + +// repeated .caffe.BlobProto blobs = 1; +inline int BlobProtoVector::blobs_size() const { + return blobs_.size(); +} +inline void BlobProtoVector::clear_blobs() { + blobs_.Clear(); +} +inline const ::caffe::BlobProto& BlobProtoVector::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.BlobProtoVector.blobs) + return blobs_.Get(index); +} +inline ::caffe::BlobProto* BlobProtoVector::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.BlobProtoVector.blobs) + return blobs_.Mutable(index); +} +inline ::caffe::BlobProto* BlobProtoVector::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.BlobProtoVector.blobs) + return blobs_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +BlobProtoVector::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.BlobProtoVector.blobs) + return &blobs_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +BlobProtoVector::blobs() const { + // @@protoc_insertion_point(field_list:caffe.BlobProtoVector.blobs) + return blobs_; +} + +inline const BlobProtoVector* BlobProtoVector::internal_default_instance() { + return &BlobProtoVector_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// PermuteParameter + +// repeated uint32 order = 1; +inline int PermuteParameter::order_size() const { + return order_.size(); +} +inline void PermuteParameter::clear_order() { + order_.Clear(); +} +inline ::google::protobuf::uint32 PermuteParameter::order(int index) const { + // @@protoc_insertion_point(field_get:caffe.PermuteParameter.order) + return order_.Get(index); +} +inline void PermuteParameter::set_order(int index, ::google::protobuf::uint32 value) { + order_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.PermuteParameter.order) +} +inline void PermuteParameter::add_order(::google::protobuf::uint32 value) { + order_.Add(value); + // @@protoc_insertion_point(field_add:caffe.PermuteParameter.order) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +PermuteParameter::order() const { + // @@protoc_insertion_point(field_list:caffe.PermuteParameter.order) + return order_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +PermuteParameter::mutable_order() { + // @@protoc_insertion_point(field_mutable_list:caffe.PermuteParameter.order) + return &order_; +} + +inline const PermuteParameter* PermuteParameter::internal_default_instance() { + return &PermuteParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NormalizeBBoxParameter + +// optional bool across_spatial = 1 [default = true]; +inline bool NormalizeBBoxParameter::has_across_spatial() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void NormalizeBBoxParameter::set_has_across_spatial() { + _has_bits_[0] |= 0x00000001u; +} +inline void NormalizeBBoxParameter::clear_has_across_spatial() { + _has_bits_[0] &= ~0x00000001u; +} +inline void NormalizeBBoxParameter::clear_across_spatial() { + across_spatial_ = true; + clear_has_across_spatial(); +} +inline bool NormalizeBBoxParameter::across_spatial() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.across_spatial) + return across_spatial_; +} +inline void NormalizeBBoxParameter::set_across_spatial(bool value) { + set_has_across_spatial(); + across_spatial_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizeBBoxParameter.across_spatial) +} + +// optional .caffe.FillerParameter scale_filler = 2; +inline bool NormalizeBBoxParameter::has_scale_filler() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void NormalizeBBoxParameter::set_has_scale_filler() { + _has_bits_[0] |= 0x00000002u; +} +inline void NormalizeBBoxParameter::clear_has_scale_filler() { + _has_bits_[0] &= ~0x00000002u; +} +inline void NormalizeBBoxParameter::clear_scale_filler() { + if (scale_filler_ != NULL) scale_filler_->::caffe::FillerParameter::Clear(); + clear_has_scale_filler(); +} +inline const ::caffe::FillerParameter& NormalizeBBoxParameter::scale_filler() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.scale_filler) + return scale_filler_ != NULL ? *scale_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* NormalizeBBoxParameter::mutable_scale_filler() { + set_has_scale_filler(); + if (scale_filler_ == NULL) { + scale_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.NormalizeBBoxParameter.scale_filler) + return scale_filler_; +} +inline ::caffe::FillerParameter* NormalizeBBoxParameter::release_scale_filler() { + // @@protoc_insertion_point(field_release:caffe.NormalizeBBoxParameter.scale_filler) + clear_has_scale_filler(); + ::caffe::FillerParameter* temp = scale_filler_; + scale_filler_ = NULL; + return temp; +} +inline void NormalizeBBoxParameter::set_allocated_scale_filler(::caffe::FillerParameter* scale_filler) { + delete scale_filler_; + scale_filler_ = scale_filler; + if (scale_filler) { + set_has_scale_filler(); + } else { + clear_has_scale_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.NormalizeBBoxParameter.scale_filler) +} + +// optional bool channel_shared = 3 [default = true]; +inline bool NormalizeBBoxParameter::has_channel_shared() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void NormalizeBBoxParameter::set_has_channel_shared() { + _has_bits_[0] |= 0x00000004u; +} +inline void NormalizeBBoxParameter::clear_has_channel_shared() { + _has_bits_[0] &= ~0x00000004u; +} +inline void NormalizeBBoxParameter::clear_channel_shared() { + channel_shared_ = true; + clear_has_channel_shared(); +} +inline bool NormalizeBBoxParameter::channel_shared() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.channel_shared) + return channel_shared_; +} +inline void NormalizeBBoxParameter::set_channel_shared(bool value) { + set_has_channel_shared(); + channel_shared_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizeBBoxParameter.channel_shared) +} + +// optional float eps = 4 [default = 1e-10]; +inline bool NormalizeBBoxParameter::has_eps() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void NormalizeBBoxParameter::set_has_eps() { + _has_bits_[0] |= 0x00000008u; +} +inline void NormalizeBBoxParameter::clear_has_eps() { + _has_bits_[0] &= ~0x00000008u; +} +inline void NormalizeBBoxParameter::clear_eps() { + eps_ = 1e-10f; + clear_has_eps(); +} +inline float NormalizeBBoxParameter::eps() const { + // @@protoc_insertion_point(field_get:caffe.NormalizeBBoxParameter.eps) + return eps_; +} +inline void NormalizeBBoxParameter::set_eps(float value) { + set_has_eps(); + eps_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizeBBoxParameter.eps) +} + +inline const NormalizeBBoxParameter* NormalizeBBoxParameter::internal_default_instance() { + return &NormalizeBBoxParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// PriorBoxParameter + +// optional float min_size = 1; +inline bool PriorBoxParameter::has_min_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PriorBoxParameter::set_has_min_size() { + _has_bits_[0] |= 0x00000001u; +} +inline void PriorBoxParameter::clear_has_min_size() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PriorBoxParameter::clear_min_size() { + min_size_ = 0; + clear_has_min_size(); +} +inline float PriorBoxParameter::min_size() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.min_size) + return min_size_; +} +inline void PriorBoxParameter::set_min_size(float value) { + set_has_min_size(); + min_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.min_size) +} + +// optional float max_size = 2; +inline bool PriorBoxParameter::has_max_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PriorBoxParameter::set_has_max_size() { + _has_bits_[0] |= 0x00000002u; +} +inline void PriorBoxParameter::clear_has_max_size() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PriorBoxParameter::clear_max_size() { + max_size_ = 0; + clear_has_max_size(); +} +inline float PriorBoxParameter::max_size() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.max_size) + return max_size_; +} +inline void PriorBoxParameter::set_max_size(float value) { + set_has_max_size(); + max_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.max_size) +} + +// repeated float aspect_ratio = 3; +inline int PriorBoxParameter::aspect_ratio_size() const { + return aspect_ratio_.size(); +} +inline void PriorBoxParameter::clear_aspect_ratio() { + aspect_ratio_.Clear(); +} +inline float PriorBoxParameter::aspect_ratio(int index) const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.aspect_ratio) + return aspect_ratio_.Get(index); +} +inline void PriorBoxParameter::set_aspect_ratio(int index, float value) { + aspect_ratio_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.aspect_ratio) +} +inline void PriorBoxParameter::add_aspect_ratio(float value) { + aspect_ratio_.Add(value); + // @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.aspect_ratio) +} +inline const ::google::protobuf::RepeatedField< float >& +PriorBoxParameter::aspect_ratio() const { + // @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.aspect_ratio) + return aspect_ratio_; +} +inline ::google::protobuf::RepeatedField< float >* +PriorBoxParameter::mutable_aspect_ratio() { + // @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.aspect_ratio) + return &aspect_ratio_; +} + +// optional bool flip = 4 [default = true]; +inline bool PriorBoxParameter::has_flip() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void PriorBoxParameter::set_has_flip() { + _has_bits_[0] |= 0x00000008u; +} +inline void PriorBoxParameter::clear_has_flip() { + _has_bits_[0] &= ~0x00000008u; +} +inline void PriorBoxParameter::clear_flip() { + flip_ = true; + clear_has_flip(); +} +inline bool PriorBoxParameter::flip() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.flip) + return flip_; +} +inline void PriorBoxParameter::set_flip(bool value) { + set_has_flip(); + flip_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.flip) +} + +// optional bool clip = 5 [default = true]; +inline bool PriorBoxParameter::has_clip() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void PriorBoxParameter::set_has_clip() { + _has_bits_[0] |= 0x00000010u; +} +inline void PriorBoxParameter::clear_has_clip() { + _has_bits_[0] &= ~0x00000010u; +} +inline void PriorBoxParameter::clear_clip() { + clip_ = true; + clear_has_clip(); +} +inline bool PriorBoxParameter::clip() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.clip) + return clip_; +} +inline void PriorBoxParameter::set_clip(bool value) { + set_has_clip(); + clip_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.clip) +} + +// repeated float variance = 6; +inline int PriorBoxParameter::variance_size() const { + return variance_.size(); +} +inline void PriorBoxParameter::clear_variance() { + variance_.Clear(); +} +inline float PriorBoxParameter::variance(int index) const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.variance) + return variance_.Get(index); +} +inline void PriorBoxParameter::set_variance(int index, float value) { + variance_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.variance) +} +inline void PriorBoxParameter::add_variance(float value) { + variance_.Add(value); + // @@protoc_insertion_point(field_add:caffe.PriorBoxParameter.variance) +} +inline const ::google::protobuf::RepeatedField< float >& +PriorBoxParameter::variance() const { + // @@protoc_insertion_point(field_list:caffe.PriorBoxParameter.variance) + return variance_; +} +inline ::google::protobuf::RepeatedField< float >* +PriorBoxParameter::mutable_variance() { + // @@protoc_insertion_point(field_mutable_list:caffe.PriorBoxParameter.variance) + return &variance_; +} + +// optional uint32 img_size = 7; +inline bool PriorBoxParameter::has_img_size() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void PriorBoxParameter::set_has_img_size() { + _has_bits_[0] |= 0x00000040u; +} +inline void PriorBoxParameter::clear_has_img_size() { + _has_bits_[0] &= ~0x00000040u; +} +inline void PriorBoxParameter::clear_img_size() { + img_size_ = 0u; + clear_has_img_size(); +} +inline ::google::protobuf::uint32 PriorBoxParameter::img_size() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_size) + return img_size_; +} +inline void PriorBoxParameter::set_img_size(::google::protobuf::uint32 value) { + set_has_img_size(); + img_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_size) +} + +// optional uint32 img_h = 8; +inline bool PriorBoxParameter::has_img_h() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void PriorBoxParameter::set_has_img_h() { + _has_bits_[0] |= 0x00000080u; +} +inline void PriorBoxParameter::clear_has_img_h() { + _has_bits_[0] &= ~0x00000080u; +} +inline void PriorBoxParameter::clear_img_h() { + img_h_ = 0u; + clear_has_img_h(); +} +inline ::google::protobuf::uint32 PriorBoxParameter::img_h() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_h) + return img_h_; +} +inline void PriorBoxParameter::set_img_h(::google::protobuf::uint32 value) { + set_has_img_h(); + img_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_h) +} + +// optional uint32 img_w = 9; +inline bool PriorBoxParameter::has_img_w() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void PriorBoxParameter::set_has_img_w() { + _has_bits_[0] |= 0x00000100u; +} +inline void PriorBoxParameter::clear_has_img_w() { + _has_bits_[0] &= ~0x00000100u; +} +inline void PriorBoxParameter::clear_img_w() { + img_w_ = 0u; + clear_has_img_w(); +} +inline ::google::protobuf::uint32 PriorBoxParameter::img_w() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.img_w) + return img_w_; +} +inline void PriorBoxParameter::set_img_w(::google::protobuf::uint32 value) { + set_has_img_w(); + img_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.img_w) +} + +// optional float step = 10; +inline bool PriorBoxParameter::has_step() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void PriorBoxParameter::set_has_step() { + _has_bits_[0] |= 0x00000200u; +} +inline void PriorBoxParameter::clear_has_step() { + _has_bits_[0] &= ~0x00000200u; +} +inline void PriorBoxParameter::clear_step() { + step_ = 0; + clear_has_step(); +} +inline float PriorBoxParameter::step() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step) + return step_; +} +inline void PriorBoxParameter::set_step(float value) { + set_has_step(); + step_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step) +} + +// optional float step_h = 11; +inline bool PriorBoxParameter::has_step_h() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void PriorBoxParameter::set_has_step_h() { + _has_bits_[0] |= 0x00000400u; +} +inline void PriorBoxParameter::clear_has_step_h() { + _has_bits_[0] &= ~0x00000400u; +} +inline void PriorBoxParameter::clear_step_h() { + step_h_ = 0; + clear_has_step_h(); +} +inline float PriorBoxParameter::step_h() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step_h) + return step_h_; +} +inline void PriorBoxParameter::set_step_h(float value) { + set_has_step_h(); + step_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step_h) +} + +// optional float step_w = 12; +inline bool PriorBoxParameter::has_step_w() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void PriorBoxParameter::set_has_step_w() { + _has_bits_[0] |= 0x00000800u; +} +inline void PriorBoxParameter::clear_has_step_w() { + _has_bits_[0] &= ~0x00000800u; +} +inline void PriorBoxParameter::clear_step_w() { + step_w_ = 0; + clear_has_step_w(); +} +inline float PriorBoxParameter::step_w() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.step_w) + return step_w_; +} +inline void PriorBoxParameter::set_step_w(float value) { + set_has_step_w(); + step_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.step_w) +} + +// optional float offset = 13 [default = 0.5]; +inline bool PriorBoxParameter::has_offset() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void PriorBoxParameter::set_has_offset() { + _has_bits_[0] |= 0x00001000u; +} +inline void PriorBoxParameter::clear_has_offset() { + _has_bits_[0] &= ~0x00001000u; +} +inline void PriorBoxParameter::clear_offset() { + offset_ = 0.5f; + clear_has_offset(); +} +inline float PriorBoxParameter::offset() const { + // @@protoc_insertion_point(field_get:caffe.PriorBoxParameter.offset) + return offset_; +} +inline void PriorBoxParameter::set_offset(float value) { + set_has_offset(); + offset_ = value; + // @@protoc_insertion_point(field_set:caffe.PriorBoxParameter.offset) +} + +inline const PriorBoxParameter* PriorBoxParameter::internal_default_instance() { + return &PriorBoxParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// DetectionOutputParameter + +// optional uint32 num_classes = 1; +inline bool DetectionOutputParameter::has_num_classes() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DetectionOutputParameter::set_has_num_classes() { + _has_bits_[0] |= 0x00000001u; +} +inline void DetectionOutputParameter::clear_has_num_classes() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DetectionOutputParameter::clear_num_classes() { + num_classes_ = 0u; + clear_has_num_classes(); +} +inline ::google::protobuf::uint32 DetectionOutputParameter::num_classes() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.num_classes) + return num_classes_; +} +inline void DetectionOutputParameter::set_num_classes(::google::protobuf::uint32 value) { + set_has_num_classes(); + num_classes_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.num_classes) +} + +// optional bool share_location = 2 [default = true]; +inline bool DetectionOutputParameter::has_share_location() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void DetectionOutputParameter::set_has_share_location() { + _has_bits_[0] |= 0x00000002u; +} +inline void DetectionOutputParameter::clear_has_share_location() { + _has_bits_[0] &= ~0x00000002u; +} +inline void DetectionOutputParameter::clear_share_location() { + share_location_ = true; + clear_has_share_location(); +} +inline bool DetectionOutputParameter::share_location() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.share_location) + return share_location_; +} +inline void DetectionOutputParameter::set_share_location(bool value) { + set_has_share_location(); + share_location_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.share_location) +} + +// optional int32 background_label_id = 3 [default = 0]; +inline bool DetectionOutputParameter::has_background_label_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void DetectionOutputParameter::set_has_background_label_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void DetectionOutputParameter::clear_has_background_label_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void DetectionOutputParameter::clear_background_label_id() { + background_label_id_ = 0; + clear_has_background_label_id(); +} +inline ::google::protobuf::int32 DetectionOutputParameter::background_label_id() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.background_label_id) + return background_label_id_; +} +inline void DetectionOutputParameter::set_background_label_id(::google::protobuf::int32 value) { + set_has_background_label_id(); + background_label_id_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.background_label_id) +} + +// optional .caffe.NonMaximumSuppressionParameter nms_param = 4; +inline bool DetectionOutputParameter::has_nms_param() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void DetectionOutputParameter::set_has_nms_param() { + _has_bits_[0] |= 0x00000008u; +} +inline void DetectionOutputParameter::clear_has_nms_param() { + _has_bits_[0] &= ~0x00000008u; +} +inline void DetectionOutputParameter::clear_nms_param() { + if (nms_param_ != NULL) nms_param_->::caffe::NonMaximumSuppressionParameter::Clear(); + clear_has_nms_param(); +} +inline const ::caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::nms_param() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.nms_param) + return nms_param_ != NULL ? *nms_param_ + : *::caffe::NonMaximumSuppressionParameter::internal_default_instance(); +} +inline ::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::mutable_nms_param() { + set_has_nms_param(); + if (nms_param_ == NULL) { + nms_param_ = new ::caffe::NonMaximumSuppressionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.DetectionOutputParameter.nms_param) + return nms_param_; +} +inline ::caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::release_nms_param() { + // @@protoc_insertion_point(field_release:caffe.DetectionOutputParameter.nms_param) + clear_has_nms_param(); + ::caffe::NonMaximumSuppressionParameter* temp = nms_param_; + nms_param_ = NULL; + return temp; +} +inline void DetectionOutputParameter::set_allocated_nms_param(::caffe::NonMaximumSuppressionParameter* nms_param) { + delete nms_param_; + nms_param_ = nms_param; + if (nms_param) { + set_has_nms_param(); + } else { + clear_has_nms_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.DetectionOutputParameter.nms_param) +} + +// optional .caffe.SaveOutputParameter save_output_param = 5; +inline bool DetectionOutputParameter::has_save_output_param() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void DetectionOutputParameter::set_has_save_output_param() { + _has_bits_[0] |= 0x00000010u; +} +inline void DetectionOutputParameter::clear_has_save_output_param() { + _has_bits_[0] &= ~0x00000010u; +} +inline void DetectionOutputParameter::clear_save_output_param() { + if (save_output_param_ != NULL) save_output_param_->::caffe::SaveOutputParameter::Clear(); + clear_has_save_output_param(); +} +inline const ::caffe::SaveOutputParameter& DetectionOutputParameter::save_output_param() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.save_output_param) + return save_output_param_ != NULL ? *save_output_param_ + : *::caffe::SaveOutputParameter::internal_default_instance(); +} +inline ::caffe::SaveOutputParameter* DetectionOutputParameter::mutable_save_output_param() { + set_has_save_output_param(); + if (save_output_param_ == NULL) { + save_output_param_ = new ::caffe::SaveOutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.DetectionOutputParameter.save_output_param) + return save_output_param_; +} +inline ::caffe::SaveOutputParameter* DetectionOutputParameter::release_save_output_param() { + // @@protoc_insertion_point(field_release:caffe.DetectionOutputParameter.save_output_param) + clear_has_save_output_param(); + ::caffe::SaveOutputParameter* temp = save_output_param_; + save_output_param_ = NULL; + return temp; +} +inline void DetectionOutputParameter::set_allocated_save_output_param(::caffe::SaveOutputParameter* save_output_param) { + delete save_output_param_; + save_output_param_ = save_output_param; + if (save_output_param) { + set_has_save_output_param(); + } else { + clear_has_save_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.DetectionOutputParameter.save_output_param) +} + +// optional .caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; +inline bool DetectionOutputParameter::has_code_type() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void DetectionOutputParameter::set_has_code_type() { + _has_bits_[0] |= 0x00000020u; +} +inline void DetectionOutputParameter::clear_has_code_type() { + _has_bits_[0] &= ~0x00000020u; +} +inline void DetectionOutputParameter::clear_code_type() { + code_type_ = 1; + clear_has_code_type(); +} +inline ::caffe::PriorBoxParameter_CodeType DetectionOutputParameter::code_type() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.code_type) + return static_cast< ::caffe::PriorBoxParameter_CodeType >(code_type_); +} +inline void DetectionOutputParameter::set_code_type(::caffe::PriorBoxParameter_CodeType value) { + assert(::caffe::PriorBoxParameter_CodeType_IsValid(value)); + set_has_code_type(); + code_type_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.code_type) +} + +// optional bool variance_encoded_in_target = 8 [default = false]; +inline bool DetectionOutputParameter::has_variance_encoded_in_target() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void DetectionOutputParameter::set_has_variance_encoded_in_target() { + _has_bits_[0] |= 0x00000040u; +} +inline void DetectionOutputParameter::clear_has_variance_encoded_in_target() { + _has_bits_[0] &= ~0x00000040u; +} +inline void DetectionOutputParameter::clear_variance_encoded_in_target() { + variance_encoded_in_target_ = false; + clear_has_variance_encoded_in_target(); +} +inline bool DetectionOutputParameter::variance_encoded_in_target() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.variance_encoded_in_target) + return variance_encoded_in_target_; +} +inline void DetectionOutputParameter::set_variance_encoded_in_target(bool value) { + set_has_variance_encoded_in_target(); + variance_encoded_in_target_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.variance_encoded_in_target) +} + +// optional int32 keep_top_k = 7 [default = -1]; +inline bool DetectionOutputParameter::has_keep_top_k() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void DetectionOutputParameter::set_has_keep_top_k() { + _has_bits_[0] |= 0x00000080u; +} +inline void DetectionOutputParameter::clear_has_keep_top_k() { + _has_bits_[0] &= ~0x00000080u; +} +inline void DetectionOutputParameter::clear_keep_top_k() { + keep_top_k_ = -1; + clear_has_keep_top_k(); +} +inline ::google::protobuf::int32 DetectionOutputParameter::keep_top_k() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.keep_top_k) + return keep_top_k_; +} +inline void DetectionOutputParameter::set_keep_top_k(::google::protobuf::int32 value) { + set_has_keep_top_k(); + keep_top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.keep_top_k) +} + +// optional float confidence_threshold = 9; +inline bool DetectionOutputParameter::has_confidence_threshold() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void DetectionOutputParameter::set_has_confidence_threshold() { + _has_bits_[0] |= 0x00000100u; +} +inline void DetectionOutputParameter::clear_has_confidence_threshold() { + _has_bits_[0] &= ~0x00000100u; +} +inline void DetectionOutputParameter::clear_confidence_threshold() { + confidence_threshold_ = 0; + clear_has_confidence_threshold(); +} +inline float DetectionOutputParameter::confidence_threshold() const { + // @@protoc_insertion_point(field_get:caffe.DetectionOutputParameter.confidence_threshold) + return confidence_threshold_; +} +inline void DetectionOutputParameter::set_confidence_threshold(float value) { + set_has_confidence_threshold(); + confidence_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.DetectionOutputParameter.confidence_threshold) +} + +inline const DetectionOutputParameter* DetectionOutputParameter::internal_default_instance() { + return &DetectionOutputParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// Datum + +// optional int32 channels = 1; +inline bool Datum::has_channels() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Datum::set_has_channels() { + _has_bits_[0] |= 0x00000001u; +} +inline void Datum::clear_has_channels() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Datum::clear_channels() { + channels_ = 0; + clear_has_channels(); +} +inline ::google::protobuf::int32 Datum::channels() const { + // @@protoc_insertion_point(field_get:caffe.Datum.channels) + return channels_; +} +inline void Datum::set_channels(::google::protobuf::int32 value) { + set_has_channels(); + channels_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.channels) +} + +// optional int32 height = 2; +inline bool Datum::has_height() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Datum::set_has_height() { + _has_bits_[0] |= 0x00000002u; +} +inline void Datum::clear_has_height() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Datum::clear_height() { + height_ = 0; + clear_has_height(); +} +inline ::google::protobuf::int32 Datum::height() const { + // @@protoc_insertion_point(field_get:caffe.Datum.height) + return height_; +} +inline void Datum::set_height(::google::protobuf::int32 value) { + set_has_height(); + height_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.height) +} + +// optional int32 width = 3; +inline bool Datum::has_width() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Datum::set_has_width() { + _has_bits_[0] |= 0x00000004u; +} +inline void Datum::clear_has_width() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Datum::clear_width() { + width_ = 0; + clear_has_width(); +} +inline ::google::protobuf::int32 Datum::width() const { + // @@protoc_insertion_point(field_get:caffe.Datum.width) + return width_; +} +inline void Datum::set_width(::google::protobuf::int32 value) { + set_has_width(); + width_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.width) +} + +// optional bytes data = 4; +inline bool Datum::has_data() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Datum::set_has_data() { + _has_bits_[0] |= 0x00000008u; +} +inline void Datum::clear_has_data() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Datum::clear_data() { + data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_data(); +} +inline const ::std::string& Datum::data() const { + // @@protoc_insertion_point(field_get:caffe.Datum.data) + return data_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void Datum::set_data(const ::std::string& value) { + set_has_data(); + data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.Datum.data) +} +inline void Datum::set_data(const char* value) { + set_has_data(); + data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.Datum.data) +} +inline void Datum::set_data(const void* value, size_t size) { + set_has_data(); + data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.Datum.data) +} +inline ::std::string* Datum::mutable_data() { + set_has_data(); + // @@protoc_insertion_point(field_mutable:caffe.Datum.data) + return data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* Datum::release_data() { + // @@protoc_insertion_point(field_release:caffe.Datum.data) + clear_has_data(); + return data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void Datum::set_allocated_data(::std::string* data) { + if (data != NULL) { + set_has_data(); + } else { + clear_has_data(); + } + data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data); + // @@protoc_insertion_point(field_set_allocated:caffe.Datum.data) +} + +// optional int32 label = 5; +inline bool Datum::has_label() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Datum::set_has_label() { + _has_bits_[0] |= 0x00000010u; +} +inline void Datum::clear_has_label() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Datum::clear_label() { + label_ = 0; + clear_has_label(); +} +inline ::google::protobuf::int32 Datum::label() const { + // @@protoc_insertion_point(field_get:caffe.Datum.label) + return label_; +} +inline void Datum::set_label(::google::protobuf::int32 value) { + set_has_label(); + label_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.label) +} + +// repeated float float_data = 6; +inline int Datum::float_data_size() const { + return float_data_.size(); +} +inline void Datum::clear_float_data() { + float_data_.Clear(); +} +inline float Datum::float_data(int index) const { + // @@protoc_insertion_point(field_get:caffe.Datum.float_data) + return float_data_.Get(index); +} +inline void Datum::set_float_data(int index, float value) { + float_data_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.Datum.float_data) +} +inline void Datum::add_float_data(float value) { + float_data_.Add(value); + // @@protoc_insertion_point(field_add:caffe.Datum.float_data) +} +inline const ::google::protobuf::RepeatedField< float >& +Datum::float_data() const { + // @@protoc_insertion_point(field_list:caffe.Datum.float_data) + return float_data_; +} +inline ::google::protobuf::RepeatedField< float >* +Datum::mutable_float_data() { + // @@protoc_insertion_point(field_mutable_list:caffe.Datum.float_data) + return &float_data_; +} + +// optional bool encoded = 7 [default = false]; +inline bool Datum::has_encoded() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Datum::set_has_encoded() { + _has_bits_[0] |= 0x00000040u; +} +inline void Datum::clear_has_encoded() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Datum::clear_encoded() { + encoded_ = false; + clear_has_encoded(); +} +inline bool Datum::encoded() const { + // @@protoc_insertion_point(field_get:caffe.Datum.encoded) + return encoded_; +} +inline void Datum::set_encoded(bool value) { + set_has_encoded(); + encoded_ = value; + // @@protoc_insertion_point(field_set:caffe.Datum.encoded) +} + +inline const Datum* Datum::internal_default_instance() { + return &Datum_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// FillerParameter + +// optional string type = 1 [default = "constant"]; +inline bool FillerParameter::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FillerParameter::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void FillerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FillerParameter::clear_type() { + type_.ClearToDefaultNoArena(_default_type_); + clear_has_type(); +} +inline const ::std::string& FillerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.type) + return type_.GetNoArena(_default_type_); +} +inline void FillerParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(_default_type_, value); + // @@protoc_insertion_point(field_set:caffe.FillerParameter.type) +} +inline void FillerParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(_default_type_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.FillerParameter.type) +} +inline void FillerParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(_default_type_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.FillerParameter.type) +} +inline ::std::string* FillerParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.FillerParameter.type) + return type_.MutableNoArena(_default_type_); +} +inline ::std::string* FillerParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.FillerParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(_default_type_); +} +inline void FillerParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(_default_type_, type); + // @@protoc_insertion_point(field_set_allocated:caffe.FillerParameter.type) +} + +// optional float value = 2 [default = 0]; +inline bool FillerParameter::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FillerParameter::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void FillerParameter::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FillerParameter::clear_value() { + value_ = 0; + clear_has_value(); +} +inline float FillerParameter::value() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.value) + return value_; +} +inline void FillerParameter::set_value(float value) { + set_has_value(); + value_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.value) +} + +// optional float min = 3 [default = 0]; +inline bool FillerParameter::has_min() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FillerParameter::set_has_min() { + _has_bits_[0] |= 0x00000004u; +} +inline void FillerParameter::clear_has_min() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FillerParameter::clear_min() { + min_ = 0; + clear_has_min(); +} +inline float FillerParameter::min() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.min) + return min_; +} +inline void FillerParameter::set_min(float value) { + set_has_min(); + min_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.min) +} + +// optional float max = 4 [default = 1]; +inline bool FillerParameter::has_max() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void FillerParameter::set_has_max() { + _has_bits_[0] |= 0x00000008u; +} +inline void FillerParameter::clear_has_max() { + _has_bits_[0] &= ~0x00000008u; +} +inline void FillerParameter::clear_max() { + max_ = 1; + clear_has_max(); +} +inline float FillerParameter::max() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.max) + return max_; +} +inline void FillerParameter::set_max(float value) { + set_has_max(); + max_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.max) +} + +// optional float mean = 5 [default = 0]; +inline bool FillerParameter::has_mean() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void FillerParameter::set_has_mean() { + _has_bits_[0] |= 0x00000010u; +} +inline void FillerParameter::clear_has_mean() { + _has_bits_[0] &= ~0x00000010u; +} +inline void FillerParameter::clear_mean() { + mean_ = 0; + clear_has_mean(); +} +inline float FillerParameter::mean() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.mean) + return mean_; +} +inline void FillerParameter::set_mean(float value) { + set_has_mean(); + mean_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.mean) +} + +// optional float std = 6 [default = 1]; +inline bool FillerParameter::has_std() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void FillerParameter::set_has_std() { + _has_bits_[0] |= 0x00000020u; +} +inline void FillerParameter::clear_has_std() { + _has_bits_[0] &= ~0x00000020u; +} +inline void FillerParameter::clear_std() { + std_ = 1; + clear_has_std(); +} +inline float FillerParameter::std() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.std) + return std_; +} +inline void FillerParameter::set_std(float value) { + set_has_std(); + std_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.std) +} + +// optional int32 sparse = 7 [default = -1]; +inline bool FillerParameter::has_sparse() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void FillerParameter::set_has_sparse() { + _has_bits_[0] |= 0x00000040u; +} +inline void FillerParameter::clear_has_sparse() { + _has_bits_[0] &= ~0x00000040u; +} +inline void FillerParameter::clear_sparse() { + sparse_ = -1; + clear_has_sparse(); +} +inline ::google::protobuf::int32 FillerParameter::sparse() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.sparse) + return sparse_; +} +inline void FillerParameter::set_sparse(::google::protobuf::int32 value) { + set_has_sparse(); + sparse_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.sparse) +} + +// optional .caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN]; +inline bool FillerParameter::has_variance_norm() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void FillerParameter::set_has_variance_norm() { + _has_bits_[0] |= 0x00000080u; +} +inline void FillerParameter::clear_has_variance_norm() { + _has_bits_[0] &= ~0x00000080u; +} +inline void FillerParameter::clear_variance_norm() { + variance_norm_ = 0; + clear_has_variance_norm(); +} +inline ::caffe::FillerParameter_VarianceNorm FillerParameter::variance_norm() const { + // @@protoc_insertion_point(field_get:caffe.FillerParameter.variance_norm) + return static_cast< ::caffe::FillerParameter_VarianceNorm >(variance_norm_); +} +inline void FillerParameter::set_variance_norm(::caffe::FillerParameter_VarianceNorm value) { + assert(::caffe::FillerParameter_VarianceNorm_IsValid(value)); + set_has_variance_norm(); + variance_norm_ = value; + // @@protoc_insertion_point(field_set:caffe.FillerParameter.variance_norm) +} + +inline const FillerParameter* FillerParameter::internal_default_instance() { + return &FillerParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NetParameter + +// optional string name = 1; +inline bool NetParameter::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void NetParameter::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void NetParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void NetParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +inline const ::std::string& NetParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void NetParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.NetParameter.name) +} +inline void NetParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.NetParameter.name) +} +inline void NetParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.NetParameter.name) +} +inline ::std::string* NetParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* NetParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.NetParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void NetParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.NetParameter.name) +} + +// repeated string input = 3; +inline int NetParameter::input_size() const { + return input_.size(); +} +inline void NetParameter::clear_input() { + input_.Clear(); +} +inline const ::std::string& NetParameter::input(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.input) + return input_.Get(index); +} +inline ::std::string* NetParameter::mutable_input(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.input) + return input_.Mutable(index); +} +inline void NetParameter::set_input(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetParameter.input) + input_.Mutable(index)->assign(value); +} +inline void NetParameter::set_input(int index, const char* value) { + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetParameter.input) +} +inline void NetParameter::set_input(int index, const char* value, size_t size) { + input_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetParameter.input) +} +inline ::std::string* NetParameter::add_input() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetParameter.input) + return input_.Add(); +} +inline void NetParameter::add_input(const ::std::string& value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetParameter.input) +} +inline void NetParameter::add_input(const char* value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetParameter.input) +} +inline void NetParameter::add_input(const char* value, size_t size) { + input_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetParameter.input) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetParameter::input() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.input) + return input_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +NetParameter::mutable_input() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input) + return &input_; +} + +// repeated .caffe.BlobShape input_shape = 8; +inline int NetParameter::input_shape_size() const { + return input_shape_.size(); +} +inline void NetParameter::clear_input_shape() { + input_shape_.Clear(); +} +inline const ::caffe::BlobShape& NetParameter::input_shape(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.input_shape) + return input_shape_.Get(index); +} +inline ::caffe::BlobShape* NetParameter::mutable_input_shape(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.input_shape) + return input_shape_.Mutable(index); +} +inline ::caffe::BlobShape* NetParameter::add_input_shape() { + // @@protoc_insertion_point(field_add:caffe.NetParameter.input_shape) + return input_shape_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* +NetParameter::mutable_input_shape() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input_shape) + return &input_shape_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& +NetParameter::input_shape() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.input_shape) + return input_shape_; +} + +// repeated int32 input_dim = 4; +inline int NetParameter::input_dim_size() const { + return input_dim_.size(); +} +inline void NetParameter::clear_input_dim() { + input_dim_.Clear(); +} +inline ::google::protobuf::int32 NetParameter::input_dim(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.input_dim) + return input_dim_.Get(index); +} +inline void NetParameter::set_input_dim(int index, ::google::protobuf::int32 value) { + input_dim_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.NetParameter.input_dim) +} +inline void NetParameter::add_input_dim(::google::protobuf::int32 value) { + input_dim_.Add(value); + // @@protoc_insertion_point(field_add:caffe.NetParameter.input_dim) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +NetParameter::input_dim() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.input_dim) + return input_dim_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +NetParameter::mutable_input_dim() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.input_dim) + return &input_dim_; +} + +// optional bool force_backward = 5 [default = false]; +inline bool NetParameter::has_force_backward() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void NetParameter::set_has_force_backward() { + _has_bits_[0] |= 0x00000010u; +} +inline void NetParameter::clear_has_force_backward() { + _has_bits_[0] &= ~0x00000010u; +} +inline void NetParameter::clear_force_backward() { + force_backward_ = false; + clear_has_force_backward(); +} +inline bool NetParameter::force_backward() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.force_backward) + return force_backward_; +} +inline void NetParameter::set_force_backward(bool value) { + set_has_force_backward(); + force_backward_ = value; + // @@protoc_insertion_point(field_set:caffe.NetParameter.force_backward) +} + +// optional .caffe.NetState state = 6; +inline bool NetParameter::has_state() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void NetParameter::set_has_state() { + _has_bits_[0] |= 0x00000020u; +} +inline void NetParameter::clear_has_state() { + _has_bits_[0] &= ~0x00000020u; +} +inline void NetParameter::clear_state() { + if (state_ != NULL) state_->::caffe::NetState::Clear(); + clear_has_state(); +} +inline const ::caffe::NetState& NetParameter::state() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.state) + return state_ != NULL ? *state_ + : *::caffe::NetState::internal_default_instance(); +} +inline ::caffe::NetState* NetParameter::mutable_state() { + set_has_state(); + if (state_ == NULL) { + state_ = new ::caffe::NetState; + } + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.state) + return state_; +} +inline ::caffe::NetState* NetParameter::release_state() { + // @@protoc_insertion_point(field_release:caffe.NetParameter.state) + clear_has_state(); + ::caffe::NetState* temp = state_; + state_ = NULL; + return temp; +} +inline void NetParameter::set_allocated_state(::caffe::NetState* state) { + delete state_; + state_ = state; + if (state) { + set_has_state(); + } else { + clear_has_state(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.NetParameter.state) +} + +// optional bool debug_info = 7 [default = false]; +inline bool NetParameter::has_debug_info() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void NetParameter::set_has_debug_info() { + _has_bits_[0] |= 0x00000040u; +} +inline void NetParameter::clear_has_debug_info() { + _has_bits_[0] &= ~0x00000040u; +} +inline void NetParameter::clear_debug_info() { + debug_info_ = false; + clear_has_debug_info(); +} +inline bool NetParameter::debug_info() const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.debug_info) + return debug_info_; +} +inline void NetParameter::set_debug_info(bool value) { + set_has_debug_info(); + debug_info_ = value; + // @@protoc_insertion_point(field_set:caffe.NetParameter.debug_info) +} + +// repeated .caffe.LayerParameter layer = 100; +inline int NetParameter::layer_size() const { + return layer_.size(); +} +inline void NetParameter::clear_layer() { + layer_.Clear(); +} +inline const ::caffe::LayerParameter& NetParameter::layer(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.layer) + return layer_.Get(index); +} +inline ::caffe::LayerParameter* NetParameter::mutable_layer(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.layer) + return layer_.Mutable(index); +} +inline ::caffe::LayerParameter* NetParameter::add_layer() { + // @@protoc_insertion_point(field_add:caffe.NetParameter.layer) + return layer_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >* +NetParameter::mutable_layer() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.layer) + return &layer_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >& +NetParameter::layer() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.layer) + return layer_; +} + +// repeated .caffe.V1LayerParameter layers = 2; +inline int NetParameter::layers_size() const { + return layers_.size(); +} +inline void NetParameter::clear_layers() { + layers_.Clear(); +} +inline const ::caffe::V1LayerParameter& NetParameter::layers(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetParameter.layers) + return layers_.Get(index); +} +inline ::caffe::V1LayerParameter* NetParameter::mutable_layers(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetParameter.layers) + return layers_.Mutable(index); +} +inline ::caffe::V1LayerParameter* NetParameter::add_layers() { + // @@protoc_insertion_point(field_add:caffe.NetParameter.layers) + return layers_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::V1LayerParameter >* +NetParameter::mutable_layers() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetParameter.layers) + return &layers_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::V1LayerParameter >& +NetParameter::layers() const { + // @@protoc_insertion_point(field_list:caffe.NetParameter.layers) + return layers_; +} + +inline const NetParameter* NetParameter::internal_default_instance() { + return &NetParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// SolverParameter + +// optional string net = 24; +inline bool SolverParameter::has_net() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SolverParameter::set_has_net() { + _has_bits_[0] |= 0x00000001u; +} +inline void SolverParameter::clear_has_net() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SolverParameter::clear_net() { + net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_net(); +} +inline const ::std::string& SolverParameter::net() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.net) + return net_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_net(const ::std::string& value) { + set_has_net(); + net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.net) +} +inline void SolverParameter::set_net(const char* value) { + set_has_net(); + net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.net) +} +inline void SolverParameter::set_net(const char* value, size_t size) { + set_has_net(); + net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.net) +} +inline ::std::string* SolverParameter::mutable_net() { + set_has_net(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.net) + return net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SolverParameter::release_net() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.net) + clear_has_net(); + return net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_allocated_net(::std::string* net) { + if (net != NULL) { + set_has_net(); + } else { + clear_has_net(); + } + net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), net); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.net) +} + +// optional .caffe.NetParameter net_param = 25; +inline bool SolverParameter::has_net_param() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SolverParameter::set_has_net_param() { + _has_bits_[0] |= 0x00000002u; +} +inline void SolverParameter::clear_has_net_param() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SolverParameter::clear_net_param() { + if (net_param_ != NULL) net_param_->::caffe::NetParameter::Clear(); + clear_has_net_param(); +} +inline const ::caffe::NetParameter& SolverParameter::net_param() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.net_param) + return net_param_ != NULL ? *net_param_ + : *::caffe::NetParameter::internal_default_instance(); +} +inline ::caffe::NetParameter* SolverParameter::mutable_net_param() { + set_has_net_param(); + if (net_param_ == NULL) { + net_param_ = new ::caffe::NetParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.net_param) + return net_param_; +} +inline ::caffe::NetParameter* SolverParameter::release_net_param() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.net_param) + clear_has_net_param(); + ::caffe::NetParameter* temp = net_param_; + net_param_ = NULL; + return temp; +} +inline void SolverParameter::set_allocated_net_param(::caffe::NetParameter* net_param) { + delete net_param_; + net_param_ = net_param; + if (net_param) { + set_has_net_param(); + } else { + clear_has_net_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.net_param) +} + +// optional string train_net = 1; +inline bool SolverParameter::has_train_net() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SolverParameter::set_has_train_net() { + _has_bits_[0] |= 0x00000004u; +} +inline void SolverParameter::clear_has_train_net() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SolverParameter::clear_train_net() { + train_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_train_net(); +} +inline const ::std::string& SolverParameter::train_net() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.train_net) + return train_net_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_train_net(const ::std::string& value) { + set_has_train_net(); + train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.train_net) +} +inline void SolverParameter::set_train_net(const char* value) { + set_has_train_net(); + train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.train_net) +} +inline void SolverParameter::set_train_net(const char* value, size_t size) { + set_has_train_net(); + train_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.train_net) +} +inline ::std::string* SolverParameter::mutable_train_net() { + set_has_train_net(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_net) + return train_net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SolverParameter::release_train_net() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.train_net) + clear_has_train_net(); + return train_net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_allocated_train_net(::std::string* train_net) { + if (train_net != NULL) { + set_has_train_net(); + } else { + clear_has_train_net(); + } + train_net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), train_net); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_net) +} + +// repeated string test_net = 2; +inline int SolverParameter::test_net_size() const { + return test_net_.size(); +} +inline void SolverParameter::clear_test_net() { + test_net_.Clear(); +} +inline const ::std::string& SolverParameter::test_net(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_net) + return test_net_.Get(index); +} +inline ::std::string* SolverParameter::mutable_test_net(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_net) + return test_net_.Mutable(index); +} +inline void SolverParameter::set_test_net(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_net) + test_net_.Mutable(index)->assign(value); +} +inline void SolverParameter::set_test_net(int index, const char* value) { + test_net_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.test_net) +} +inline void SolverParameter::set_test_net(int index, const char* value, size_t size) { + test_net_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.test_net) +} +inline ::std::string* SolverParameter::add_test_net() { + // @@protoc_insertion_point(field_add_mutable:caffe.SolverParameter.test_net) + return test_net_.Add(); +} +inline void SolverParameter::add_test_net(const ::std::string& value) { + test_net_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_net) +} +inline void SolverParameter::add_test_net(const char* value) { + test_net_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.SolverParameter.test_net) +} +inline void SolverParameter::add_test_net(const char* value, size_t size) { + test_net_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.SolverParameter.test_net) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +SolverParameter::test_net() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_net) + return test_net_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +SolverParameter::mutable_test_net() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_net) + return &test_net_; +} + +// optional .caffe.NetParameter train_net_param = 21; +inline bool SolverParameter::has_train_net_param() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SolverParameter::set_has_train_net_param() { + _has_bits_[0] |= 0x00000010u; +} +inline void SolverParameter::clear_has_train_net_param() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SolverParameter::clear_train_net_param() { + if (train_net_param_ != NULL) train_net_param_->::caffe::NetParameter::Clear(); + clear_has_train_net_param(); +} +inline const ::caffe::NetParameter& SolverParameter::train_net_param() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.train_net_param) + return train_net_param_ != NULL ? *train_net_param_ + : *::caffe::NetParameter::internal_default_instance(); +} +inline ::caffe::NetParameter* SolverParameter::mutable_train_net_param() { + set_has_train_net_param(); + if (train_net_param_ == NULL) { + train_net_param_ = new ::caffe::NetParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_net_param) + return train_net_param_; +} +inline ::caffe::NetParameter* SolverParameter::release_train_net_param() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.train_net_param) + clear_has_train_net_param(); + ::caffe::NetParameter* temp = train_net_param_; + train_net_param_ = NULL; + return temp; +} +inline void SolverParameter::set_allocated_train_net_param(::caffe::NetParameter* train_net_param) { + delete train_net_param_; + train_net_param_ = train_net_param; + if (train_net_param) { + set_has_train_net_param(); + } else { + clear_has_train_net_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_net_param) +} + +// repeated .caffe.NetParameter test_net_param = 22; +inline int SolverParameter::test_net_param_size() const { + return test_net_param_.size(); +} +inline void SolverParameter::clear_test_net_param() { + test_net_param_.Clear(); +} +inline const ::caffe::NetParameter& SolverParameter::test_net_param(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_net_param) + return test_net_param_.Get(index); +} +inline ::caffe::NetParameter* SolverParameter::mutable_test_net_param(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_net_param) + return test_net_param_.Mutable(index); +} +inline ::caffe::NetParameter* SolverParameter::add_test_net_param() { + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_net_param) + return test_net_param_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >* +SolverParameter::mutable_test_net_param() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_net_param) + return &test_net_param_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >& +SolverParameter::test_net_param() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_net_param) + return test_net_param_; +} + +// optional .caffe.NetState train_state = 26; +inline bool SolverParameter::has_train_state() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void SolverParameter::set_has_train_state() { + _has_bits_[0] |= 0x00000040u; +} +inline void SolverParameter::clear_has_train_state() { + _has_bits_[0] &= ~0x00000040u; +} +inline void SolverParameter::clear_train_state() { + if (train_state_ != NULL) train_state_->::caffe::NetState::Clear(); + clear_has_train_state(); +} +inline const ::caffe::NetState& SolverParameter::train_state() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.train_state) + return train_state_ != NULL ? *train_state_ + : *::caffe::NetState::internal_default_instance(); +} +inline ::caffe::NetState* SolverParameter::mutable_train_state() { + set_has_train_state(); + if (train_state_ == NULL) { + train_state_ = new ::caffe::NetState; + } + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.train_state) + return train_state_; +} +inline ::caffe::NetState* SolverParameter::release_train_state() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.train_state) + clear_has_train_state(); + ::caffe::NetState* temp = train_state_; + train_state_ = NULL; + return temp; +} +inline void SolverParameter::set_allocated_train_state(::caffe::NetState* train_state) { + delete train_state_; + train_state_ = train_state; + if (train_state) { + set_has_train_state(); + } else { + clear_has_train_state(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.train_state) +} + +// repeated .caffe.NetState test_state = 27; +inline int SolverParameter::test_state_size() const { + return test_state_.size(); +} +inline void SolverParameter::clear_test_state() { + test_state_.Clear(); +} +inline const ::caffe::NetState& SolverParameter::test_state(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_state) + return test_state_.Get(index); +} +inline ::caffe::NetState* SolverParameter::mutable_test_state(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.test_state) + return test_state_.Mutable(index); +} +inline ::caffe::NetState* SolverParameter::add_test_state() { + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_state) + return test_state_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::NetState >* +SolverParameter::mutable_test_state() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_state) + return &test_state_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetState >& +SolverParameter::test_state() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_state) + return test_state_; +} + +// repeated int32 test_iter = 3; +inline int SolverParameter::test_iter_size() const { + return test_iter_.size(); +} +inline void SolverParameter::clear_test_iter() { + test_iter_.Clear(); +} +inline ::google::protobuf::int32 SolverParameter::test_iter(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_iter) + return test_iter_.Get(index); +} +inline void SolverParameter::set_test_iter(int index, ::google::protobuf::int32 value) { + test_iter_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_iter) +} +inline void SolverParameter::add_test_iter(::google::protobuf::int32 value) { + test_iter_.Add(value); + // @@protoc_insertion_point(field_add:caffe.SolverParameter.test_iter) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +SolverParameter::test_iter() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.test_iter) + return test_iter_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +SolverParameter::mutable_test_iter() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.test_iter) + return &test_iter_; +} + +// optional int32 test_interval = 4 [default = 0]; +inline bool SolverParameter::has_test_interval() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void SolverParameter::set_has_test_interval() { + _has_bits_[0] |= 0x00000200u; +} +inline void SolverParameter::clear_has_test_interval() { + _has_bits_[0] &= ~0x00000200u; +} +inline void SolverParameter::clear_test_interval() { + test_interval_ = 0; + clear_has_test_interval(); +} +inline ::google::protobuf::int32 SolverParameter::test_interval() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_interval) + return test_interval_; +} +inline void SolverParameter::set_test_interval(::google::protobuf::int32 value) { + set_has_test_interval(); + test_interval_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_interval) +} + +// optional bool test_compute_loss = 19 [default = false]; +inline bool SolverParameter::has_test_compute_loss() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void SolverParameter::set_has_test_compute_loss() { + _has_bits_[0] |= 0x00000400u; +} +inline void SolverParameter::clear_has_test_compute_loss() { + _has_bits_[0] &= ~0x00000400u; +} +inline void SolverParameter::clear_test_compute_loss() { + test_compute_loss_ = false; + clear_has_test_compute_loss(); +} +inline bool SolverParameter::test_compute_loss() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_compute_loss) + return test_compute_loss_; +} +inline void SolverParameter::set_test_compute_loss(bool value) { + set_has_test_compute_loss(); + test_compute_loss_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_compute_loss) +} + +// optional bool test_initialization = 32 [default = true]; +inline bool SolverParameter::has_test_initialization() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void SolverParameter::set_has_test_initialization() { + _has_bits_[0] |= 0x00000800u; +} +inline void SolverParameter::clear_has_test_initialization() { + _has_bits_[0] &= ~0x00000800u; +} +inline void SolverParameter::clear_test_initialization() { + test_initialization_ = true; + clear_has_test_initialization(); +} +inline bool SolverParameter::test_initialization() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.test_initialization) + return test_initialization_; +} +inline void SolverParameter::set_test_initialization(bool value) { + set_has_test_initialization(); + test_initialization_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.test_initialization) +} + +// optional float base_lr = 5; +inline bool SolverParameter::has_base_lr() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void SolverParameter::set_has_base_lr() { + _has_bits_[0] |= 0x00001000u; +} +inline void SolverParameter::clear_has_base_lr() { + _has_bits_[0] &= ~0x00001000u; +} +inline void SolverParameter::clear_base_lr() { + base_lr_ = 0; + clear_has_base_lr(); +} +inline float SolverParameter::base_lr() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.base_lr) + return base_lr_; +} +inline void SolverParameter::set_base_lr(float value) { + set_has_base_lr(); + base_lr_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.base_lr) +} + +// optional int32 display = 6; +inline bool SolverParameter::has_display() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void SolverParameter::set_has_display() { + _has_bits_[0] |= 0x00002000u; +} +inline void SolverParameter::clear_has_display() { + _has_bits_[0] &= ~0x00002000u; +} +inline void SolverParameter::clear_display() { + display_ = 0; + clear_has_display(); +} +inline ::google::protobuf::int32 SolverParameter::display() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.display) + return display_; +} +inline void SolverParameter::set_display(::google::protobuf::int32 value) { + set_has_display(); + display_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.display) +} + +// optional int32 average_loss = 33 [default = 1]; +inline bool SolverParameter::has_average_loss() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void SolverParameter::set_has_average_loss() { + _has_bits_[0] |= 0x00004000u; +} +inline void SolverParameter::clear_has_average_loss() { + _has_bits_[0] &= ~0x00004000u; +} +inline void SolverParameter::clear_average_loss() { + average_loss_ = 1; + clear_has_average_loss(); +} +inline ::google::protobuf::int32 SolverParameter::average_loss() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.average_loss) + return average_loss_; +} +inline void SolverParameter::set_average_loss(::google::protobuf::int32 value) { + set_has_average_loss(); + average_loss_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.average_loss) +} + +// optional int32 max_iter = 7; +inline bool SolverParameter::has_max_iter() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void SolverParameter::set_has_max_iter() { + _has_bits_[0] |= 0x00008000u; +} +inline void SolverParameter::clear_has_max_iter() { + _has_bits_[0] &= ~0x00008000u; +} +inline void SolverParameter::clear_max_iter() { + max_iter_ = 0; + clear_has_max_iter(); +} +inline ::google::protobuf::int32 SolverParameter::max_iter() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.max_iter) + return max_iter_; +} +inline void SolverParameter::set_max_iter(::google::protobuf::int32 value) { + set_has_max_iter(); + max_iter_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.max_iter) +} + +// optional int32 iter_size = 36 [default = 1]; +inline bool SolverParameter::has_iter_size() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +inline void SolverParameter::set_has_iter_size() { + _has_bits_[0] |= 0x00010000u; +} +inline void SolverParameter::clear_has_iter_size() { + _has_bits_[0] &= ~0x00010000u; +} +inline void SolverParameter::clear_iter_size() { + iter_size_ = 1; + clear_has_iter_size(); +} +inline ::google::protobuf::int32 SolverParameter::iter_size() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.iter_size) + return iter_size_; +} +inline void SolverParameter::set_iter_size(::google::protobuf::int32 value) { + set_has_iter_size(); + iter_size_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.iter_size) +} + +// optional string lr_policy = 8; +inline bool SolverParameter::has_lr_policy() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +inline void SolverParameter::set_has_lr_policy() { + _has_bits_[0] |= 0x00020000u; +} +inline void SolverParameter::clear_has_lr_policy() { + _has_bits_[0] &= ~0x00020000u; +} +inline void SolverParameter::clear_lr_policy() { + lr_policy_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_lr_policy(); +} +inline const ::std::string& SolverParameter::lr_policy() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.lr_policy) + return lr_policy_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_lr_policy(const ::std::string& value) { + set_has_lr_policy(); + lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.lr_policy) +} +inline void SolverParameter::set_lr_policy(const char* value) { + set_has_lr_policy(); + lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.lr_policy) +} +inline void SolverParameter::set_lr_policy(const char* value, size_t size) { + set_has_lr_policy(); + lr_policy_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.lr_policy) +} +inline ::std::string* SolverParameter::mutable_lr_policy() { + set_has_lr_policy(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.lr_policy) + return lr_policy_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SolverParameter::release_lr_policy() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.lr_policy) + clear_has_lr_policy(); + return lr_policy_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_allocated_lr_policy(::std::string* lr_policy) { + if (lr_policy != NULL) { + set_has_lr_policy(); + } else { + clear_has_lr_policy(); + } + lr_policy_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), lr_policy); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.lr_policy) +} + +// optional float gamma = 9; +inline bool SolverParameter::has_gamma() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +inline void SolverParameter::set_has_gamma() { + _has_bits_[0] |= 0x00040000u; +} +inline void SolverParameter::clear_has_gamma() { + _has_bits_[0] &= ~0x00040000u; +} +inline void SolverParameter::clear_gamma() { + gamma_ = 0; + clear_has_gamma(); +} +inline float SolverParameter::gamma() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.gamma) + return gamma_; +} +inline void SolverParameter::set_gamma(float value) { + set_has_gamma(); + gamma_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.gamma) +} + +// optional float power = 10; +inline bool SolverParameter::has_power() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +inline void SolverParameter::set_has_power() { + _has_bits_[0] |= 0x00080000u; +} +inline void SolverParameter::clear_has_power() { + _has_bits_[0] &= ~0x00080000u; +} +inline void SolverParameter::clear_power() { + power_ = 0; + clear_has_power(); +} +inline float SolverParameter::power() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.power) + return power_; +} +inline void SolverParameter::set_power(float value) { + set_has_power(); + power_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.power) +} + +// optional float momentum = 11; +inline bool SolverParameter::has_momentum() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +inline void SolverParameter::set_has_momentum() { + _has_bits_[0] |= 0x00100000u; +} +inline void SolverParameter::clear_has_momentum() { + _has_bits_[0] &= ~0x00100000u; +} +inline void SolverParameter::clear_momentum() { + momentum_ = 0; + clear_has_momentum(); +} +inline float SolverParameter::momentum() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.momentum) + return momentum_; +} +inline void SolverParameter::set_momentum(float value) { + set_has_momentum(); + momentum_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.momentum) +} + +// optional float weight_decay = 12; +inline bool SolverParameter::has_weight_decay() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +inline void SolverParameter::set_has_weight_decay() { + _has_bits_[0] |= 0x00200000u; +} +inline void SolverParameter::clear_has_weight_decay() { + _has_bits_[0] &= ~0x00200000u; +} +inline void SolverParameter::clear_weight_decay() { + weight_decay_ = 0; + clear_has_weight_decay(); +} +inline float SolverParameter::weight_decay() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.weight_decay) + return weight_decay_; +} +inline void SolverParameter::set_weight_decay(float value) { + set_has_weight_decay(); + weight_decay_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.weight_decay) +} + +// optional string regularization_type = 29 [default = "L2"]; +inline bool SolverParameter::has_regularization_type() const { + return (_has_bits_[0] & 0x00400000u) != 0; +} +inline void SolverParameter::set_has_regularization_type() { + _has_bits_[0] |= 0x00400000u; +} +inline void SolverParameter::clear_has_regularization_type() { + _has_bits_[0] &= ~0x00400000u; +} +inline void SolverParameter::clear_regularization_type() { + regularization_type_.ClearToDefaultNoArena(_default_regularization_type_); + clear_has_regularization_type(); +} +inline const ::std::string& SolverParameter::regularization_type() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.regularization_type) + return regularization_type_.GetNoArena(_default_regularization_type_); +} +inline void SolverParameter::set_regularization_type(const ::std::string& value) { + set_has_regularization_type(); + regularization_type_.SetNoArena(_default_regularization_type_, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.regularization_type) +} +inline void SolverParameter::set_regularization_type(const char* value) { + set_has_regularization_type(); + regularization_type_.SetNoArena(_default_regularization_type_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.regularization_type) +} +inline void SolverParameter::set_regularization_type(const char* value, size_t size) { + set_has_regularization_type(); + regularization_type_.SetNoArena(_default_regularization_type_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.regularization_type) +} +inline ::std::string* SolverParameter::mutable_regularization_type() { + set_has_regularization_type(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.regularization_type) + return regularization_type_.MutableNoArena(_default_regularization_type_); +} +inline ::std::string* SolverParameter::release_regularization_type() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.regularization_type) + clear_has_regularization_type(); + return regularization_type_.ReleaseNoArena(_default_regularization_type_); +} +inline void SolverParameter::set_allocated_regularization_type(::std::string* regularization_type) { + if (regularization_type != NULL) { + set_has_regularization_type(); + } else { + clear_has_regularization_type(); + } + regularization_type_.SetAllocatedNoArena(_default_regularization_type_, regularization_type); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.regularization_type) +} + +// optional int32 stepsize = 13; +inline bool SolverParameter::has_stepsize() const { + return (_has_bits_[0] & 0x00800000u) != 0; +} +inline void SolverParameter::set_has_stepsize() { + _has_bits_[0] |= 0x00800000u; +} +inline void SolverParameter::clear_has_stepsize() { + _has_bits_[0] &= ~0x00800000u; +} +inline void SolverParameter::clear_stepsize() { + stepsize_ = 0; + clear_has_stepsize(); +} +inline ::google::protobuf::int32 SolverParameter::stepsize() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.stepsize) + return stepsize_; +} +inline void SolverParameter::set_stepsize(::google::protobuf::int32 value) { + set_has_stepsize(); + stepsize_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.stepsize) +} + +// repeated int32 stepvalue = 34; +inline int SolverParameter::stepvalue_size() const { + return stepvalue_.size(); +} +inline void SolverParameter::clear_stepvalue() { + stepvalue_.Clear(); +} +inline ::google::protobuf::int32 SolverParameter::stepvalue(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.stepvalue) + return stepvalue_.Get(index); +} +inline void SolverParameter::set_stepvalue(int index, ::google::protobuf::int32 value) { + stepvalue_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.stepvalue) +} +inline void SolverParameter::add_stepvalue(::google::protobuf::int32 value) { + stepvalue_.Add(value); + // @@protoc_insertion_point(field_add:caffe.SolverParameter.stepvalue) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +SolverParameter::stepvalue() const { + // @@protoc_insertion_point(field_list:caffe.SolverParameter.stepvalue) + return stepvalue_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +SolverParameter::mutable_stepvalue() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverParameter.stepvalue) + return &stepvalue_; +} + +// optional float clip_gradients = 35 [default = -1]; +inline bool SolverParameter::has_clip_gradients() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +inline void SolverParameter::set_has_clip_gradients() { + _has_bits_[0] |= 0x02000000u; +} +inline void SolverParameter::clear_has_clip_gradients() { + _has_bits_[0] &= ~0x02000000u; +} +inline void SolverParameter::clear_clip_gradients() { + clip_gradients_ = -1; + clear_has_clip_gradients(); +} +inline float SolverParameter::clip_gradients() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.clip_gradients) + return clip_gradients_; +} +inline void SolverParameter::set_clip_gradients(float value) { + set_has_clip_gradients(); + clip_gradients_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.clip_gradients) +} + +// optional int32 snapshot = 14 [default = 0]; +inline bool SolverParameter::has_snapshot() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +inline void SolverParameter::set_has_snapshot() { + _has_bits_[0] |= 0x04000000u; +} +inline void SolverParameter::clear_has_snapshot() { + _has_bits_[0] &= ~0x04000000u; +} +inline void SolverParameter::clear_snapshot() { + snapshot_ = 0; + clear_has_snapshot(); +} +inline ::google::protobuf::int32 SolverParameter::snapshot() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot) + return snapshot_; +} +inline void SolverParameter::set_snapshot(::google::protobuf::int32 value) { + set_has_snapshot(); + snapshot_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot) +} + +// optional string snapshot_prefix = 15; +inline bool SolverParameter::has_snapshot_prefix() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +inline void SolverParameter::set_has_snapshot_prefix() { + _has_bits_[0] |= 0x08000000u; +} +inline void SolverParameter::clear_has_snapshot_prefix() { + _has_bits_[0] &= ~0x08000000u; +} +inline void SolverParameter::clear_snapshot_prefix() { + snapshot_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_snapshot_prefix(); +} +inline const ::std::string& SolverParameter::snapshot_prefix() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_prefix) + return snapshot_prefix_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_snapshot_prefix(const ::std::string& value) { + set_has_snapshot_prefix(); + snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_prefix) +} +inline void SolverParameter::set_snapshot_prefix(const char* value) { + set_has_snapshot_prefix(); + snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.snapshot_prefix) +} +inline void SolverParameter::set_snapshot_prefix(const char* value, size_t size) { + set_has_snapshot_prefix(); + snapshot_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.snapshot_prefix) +} +inline ::std::string* SolverParameter::mutable_snapshot_prefix() { + set_has_snapshot_prefix(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.snapshot_prefix) + return snapshot_prefix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SolverParameter::release_snapshot_prefix() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.snapshot_prefix) + clear_has_snapshot_prefix(); + return snapshot_prefix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverParameter::set_allocated_snapshot_prefix(::std::string* snapshot_prefix) { + if (snapshot_prefix != NULL) { + set_has_snapshot_prefix(); + } else { + clear_has_snapshot_prefix(); + } + snapshot_prefix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), snapshot_prefix); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.snapshot_prefix) +} + +// optional bool snapshot_diff = 16 [default = false]; +inline bool SolverParameter::has_snapshot_diff() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +inline void SolverParameter::set_has_snapshot_diff() { + _has_bits_[0] |= 0x10000000u; +} +inline void SolverParameter::clear_has_snapshot_diff() { + _has_bits_[0] &= ~0x10000000u; +} +inline void SolverParameter::clear_snapshot_diff() { + snapshot_diff_ = false; + clear_has_snapshot_diff(); +} +inline bool SolverParameter::snapshot_diff() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_diff) + return snapshot_diff_; +} +inline void SolverParameter::set_snapshot_diff(bool value) { + set_has_snapshot_diff(); + snapshot_diff_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_diff) +} + +// optional .caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; +inline bool SolverParameter::has_snapshot_format() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +inline void SolverParameter::set_has_snapshot_format() { + _has_bits_[0] |= 0x20000000u; +} +inline void SolverParameter::clear_has_snapshot_format() { + _has_bits_[0] &= ~0x20000000u; +} +inline void SolverParameter::clear_snapshot_format() { + snapshot_format_ = 1; + clear_has_snapshot_format(); +} +inline ::caffe::SolverParameter_SnapshotFormat SolverParameter::snapshot_format() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_format) + return static_cast< ::caffe::SolverParameter_SnapshotFormat >(snapshot_format_); +} +inline void SolverParameter::set_snapshot_format(::caffe::SolverParameter_SnapshotFormat value) { + assert(::caffe::SolverParameter_SnapshotFormat_IsValid(value)); + set_has_snapshot_format(); + snapshot_format_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_format) +} + +// optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU]; +inline bool SolverParameter::has_solver_mode() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +inline void SolverParameter::set_has_solver_mode() { + _has_bits_[0] |= 0x40000000u; +} +inline void SolverParameter::clear_has_solver_mode() { + _has_bits_[0] &= ~0x40000000u; +} +inline void SolverParameter::clear_solver_mode() { + solver_mode_ = 1; + clear_has_solver_mode(); +} +inline ::caffe::SolverParameter_SolverMode SolverParameter::solver_mode() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.solver_mode) + return static_cast< ::caffe::SolverParameter_SolverMode >(solver_mode_); +} +inline void SolverParameter::set_solver_mode(::caffe::SolverParameter_SolverMode value) { + assert(::caffe::SolverParameter_SolverMode_IsValid(value)); + set_has_solver_mode(); + solver_mode_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.solver_mode) +} + +// optional int32 device_id = 18 [default = 0]; +inline bool SolverParameter::has_device_id() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +inline void SolverParameter::set_has_device_id() { + _has_bits_[0] |= 0x80000000u; +} +inline void SolverParameter::clear_has_device_id() { + _has_bits_[0] &= ~0x80000000u; +} +inline void SolverParameter::clear_device_id() { + device_id_ = 0; + clear_has_device_id(); +} +inline ::google::protobuf::int32 SolverParameter::device_id() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.device_id) + return device_id_; +} +inline void SolverParameter::set_device_id(::google::protobuf::int32 value) { + set_has_device_id(); + device_id_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.device_id) +} + +// optional int64 random_seed = 20 [default = -1]; +inline bool SolverParameter::has_random_seed() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +inline void SolverParameter::set_has_random_seed() { + _has_bits_[1] |= 0x00000001u; +} +inline void SolverParameter::clear_has_random_seed() { + _has_bits_[1] &= ~0x00000001u; +} +inline void SolverParameter::clear_random_seed() { + random_seed_ = GOOGLE_LONGLONG(-1); + clear_has_random_seed(); +} +inline ::google::protobuf::int64 SolverParameter::random_seed() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.random_seed) + return random_seed_; +} +inline void SolverParameter::set_random_seed(::google::protobuf::int64 value) { + set_has_random_seed(); + random_seed_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.random_seed) +} + +// optional string type = 40 [default = "SGD"]; +inline bool SolverParameter::has_type() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +inline void SolverParameter::set_has_type() { + _has_bits_[1] |= 0x00000002u; +} +inline void SolverParameter::clear_has_type() { + _has_bits_[1] &= ~0x00000002u; +} +inline void SolverParameter::clear_type() { + type_.ClearToDefaultNoArena(_default_type_); + clear_has_type(); +} +inline const ::std::string& SolverParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.type) + return type_.GetNoArena(_default_type_); +} +inline void SolverParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(_default_type_, value); + // @@protoc_insertion_point(field_set:caffe.SolverParameter.type) +} +inline void SolverParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(_default_type_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverParameter.type) +} +inline void SolverParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(_default_type_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverParameter.type) +} +inline ::std::string* SolverParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.SolverParameter.type) + return type_.MutableNoArena(_default_type_); +} +inline ::std::string* SolverParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.SolverParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(_default_type_); +} +inline void SolverParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(_default_type_, type); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverParameter.type) +} + +// optional float delta = 31 [default = 1e-08]; +inline bool SolverParameter::has_delta() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +inline void SolverParameter::set_has_delta() { + _has_bits_[1] |= 0x00000004u; +} +inline void SolverParameter::clear_has_delta() { + _has_bits_[1] &= ~0x00000004u; +} +inline void SolverParameter::clear_delta() { + delta_ = 1e-08f; + clear_has_delta(); +} +inline float SolverParameter::delta() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.delta) + return delta_; +} +inline void SolverParameter::set_delta(float value) { + set_has_delta(); + delta_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.delta) +} + +// optional float momentum2 = 39 [default = 0.999]; +inline bool SolverParameter::has_momentum2() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +inline void SolverParameter::set_has_momentum2() { + _has_bits_[1] |= 0x00000008u; +} +inline void SolverParameter::clear_has_momentum2() { + _has_bits_[1] &= ~0x00000008u; +} +inline void SolverParameter::clear_momentum2() { + momentum2_ = 0.999f; + clear_has_momentum2(); +} +inline float SolverParameter::momentum2() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.momentum2) + return momentum2_; +} +inline void SolverParameter::set_momentum2(float value) { + set_has_momentum2(); + momentum2_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.momentum2) +} + +// optional float rms_decay = 38 [default = 0.99]; +inline bool SolverParameter::has_rms_decay() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +inline void SolverParameter::set_has_rms_decay() { + _has_bits_[1] |= 0x00000010u; +} +inline void SolverParameter::clear_has_rms_decay() { + _has_bits_[1] &= ~0x00000010u; +} +inline void SolverParameter::clear_rms_decay() { + rms_decay_ = 0.99f; + clear_has_rms_decay(); +} +inline float SolverParameter::rms_decay() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.rms_decay) + return rms_decay_; +} +inline void SolverParameter::set_rms_decay(float value) { + set_has_rms_decay(); + rms_decay_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.rms_decay) +} + +// optional bool debug_info = 23 [default = false]; +inline bool SolverParameter::has_debug_info() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +inline void SolverParameter::set_has_debug_info() { + _has_bits_[1] |= 0x00000020u; +} +inline void SolverParameter::clear_has_debug_info() { + _has_bits_[1] &= ~0x00000020u; +} +inline void SolverParameter::clear_debug_info() { + debug_info_ = false; + clear_has_debug_info(); +} +inline bool SolverParameter::debug_info() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.debug_info) + return debug_info_; +} +inline void SolverParameter::set_debug_info(bool value) { + set_has_debug_info(); + debug_info_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.debug_info) +} + +// optional bool snapshot_after_train = 28 [default = true]; +inline bool SolverParameter::has_snapshot_after_train() const { + return (_has_bits_[1] & 0x00000040u) != 0; +} +inline void SolverParameter::set_has_snapshot_after_train() { + _has_bits_[1] |= 0x00000040u; +} +inline void SolverParameter::clear_has_snapshot_after_train() { + _has_bits_[1] &= ~0x00000040u; +} +inline void SolverParameter::clear_snapshot_after_train() { + snapshot_after_train_ = true; + clear_has_snapshot_after_train(); +} +inline bool SolverParameter::snapshot_after_train() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.snapshot_after_train) + return snapshot_after_train_; +} +inline void SolverParameter::set_snapshot_after_train(bool value) { + set_has_snapshot_after_train(); + snapshot_after_train_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.snapshot_after_train) +} + +// optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD]; +inline bool SolverParameter::has_solver_type() const { + return (_has_bits_[1] & 0x00000080u) != 0; +} +inline void SolverParameter::set_has_solver_type() { + _has_bits_[1] |= 0x00000080u; +} +inline void SolverParameter::clear_has_solver_type() { + _has_bits_[1] &= ~0x00000080u; +} +inline void SolverParameter::clear_solver_type() { + solver_type_ = 0; + clear_has_solver_type(); +} +inline ::caffe::SolverParameter_SolverType SolverParameter::solver_type() const { + // @@protoc_insertion_point(field_get:caffe.SolverParameter.solver_type) + return static_cast< ::caffe::SolverParameter_SolverType >(solver_type_); +} +inline void SolverParameter::set_solver_type(::caffe::SolverParameter_SolverType value) { + assert(::caffe::SolverParameter_SolverType_IsValid(value)); + set_has_solver_type(); + solver_type_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverParameter.solver_type) +} + +inline const SolverParameter* SolverParameter::internal_default_instance() { + return &SolverParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// SolverState + +// optional int32 iter = 1; +inline bool SolverState::has_iter() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SolverState::set_has_iter() { + _has_bits_[0] |= 0x00000001u; +} +inline void SolverState::clear_has_iter() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SolverState::clear_iter() { + iter_ = 0; + clear_has_iter(); +} +inline ::google::protobuf::int32 SolverState::iter() const { + // @@protoc_insertion_point(field_get:caffe.SolverState.iter) + return iter_; +} +inline void SolverState::set_iter(::google::protobuf::int32 value) { + set_has_iter(); + iter_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverState.iter) +} + +// optional string learned_net = 2; +inline bool SolverState::has_learned_net() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SolverState::set_has_learned_net() { + _has_bits_[0] |= 0x00000002u; +} +inline void SolverState::clear_has_learned_net() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SolverState::clear_learned_net() { + learned_net_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_learned_net(); +} +inline const ::std::string& SolverState::learned_net() const { + // @@protoc_insertion_point(field_get:caffe.SolverState.learned_net) + return learned_net_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverState::set_learned_net(const ::std::string& value) { + set_has_learned_net(); + learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SolverState.learned_net) +} +inline void SolverState::set_learned_net(const char* value) { + set_has_learned_net(); + learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SolverState.learned_net) +} +inline void SolverState::set_learned_net(const char* value, size_t size) { + set_has_learned_net(); + learned_net_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SolverState.learned_net) +} +inline ::std::string* SolverState::mutable_learned_net() { + set_has_learned_net(); + // @@protoc_insertion_point(field_mutable:caffe.SolverState.learned_net) + return learned_net_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SolverState::release_learned_net() { + // @@protoc_insertion_point(field_release:caffe.SolverState.learned_net) + clear_has_learned_net(); + return learned_net_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SolverState::set_allocated_learned_net(::std::string* learned_net) { + if (learned_net != NULL) { + set_has_learned_net(); + } else { + clear_has_learned_net(); + } + learned_net_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), learned_net); + // @@protoc_insertion_point(field_set_allocated:caffe.SolverState.learned_net) +} + +// repeated .caffe.BlobProto history = 3; +inline int SolverState::history_size() const { + return history_.size(); +} +inline void SolverState::clear_history() { + history_.Clear(); +} +inline const ::caffe::BlobProto& SolverState::history(int index) const { + // @@protoc_insertion_point(field_get:caffe.SolverState.history) + return history_.Get(index); +} +inline ::caffe::BlobProto* SolverState::mutable_history(int index) { + // @@protoc_insertion_point(field_mutable:caffe.SolverState.history) + return history_.Mutable(index); +} +inline ::caffe::BlobProto* SolverState::add_history() { + // @@protoc_insertion_point(field_add:caffe.SolverState.history) + return history_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +SolverState::mutable_history() { + // @@protoc_insertion_point(field_mutable_list:caffe.SolverState.history) + return &history_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +SolverState::history() const { + // @@protoc_insertion_point(field_list:caffe.SolverState.history) + return history_; +} + +// optional int32 current_step = 4 [default = 0]; +inline bool SolverState::has_current_step() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void SolverState::set_has_current_step() { + _has_bits_[0] |= 0x00000008u; +} +inline void SolverState::clear_has_current_step() { + _has_bits_[0] &= ~0x00000008u; +} +inline void SolverState::clear_current_step() { + current_step_ = 0; + clear_has_current_step(); +} +inline ::google::protobuf::int32 SolverState::current_step() const { + // @@protoc_insertion_point(field_get:caffe.SolverState.current_step) + return current_step_; +} +inline void SolverState::set_current_step(::google::protobuf::int32 value) { + set_has_current_step(); + current_step_ = value; + // @@protoc_insertion_point(field_set:caffe.SolverState.current_step) +} + +inline const SolverState* SolverState::internal_default_instance() { + return &SolverState_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NetState + +// optional .caffe.Phase phase = 1 [default = TEST]; +inline bool NetState::has_phase() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void NetState::set_has_phase() { + _has_bits_[0] |= 0x00000001u; +} +inline void NetState::clear_has_phase() { + _has_bits_[0] &= ~0x00000001u; +} +inline void NetState::clear_phase() { + phase_ = 1; + clear_has_phase(); +} +inline ::caffe::Phase NetState::phase() const { + // @@protoc_insertion_point(field_get:caffe.NetState.phase) + return static_cast< ::caffe::Phase >(phase_); +} +inline void NetState::set_phase(::caffe::Phase value) { + assert(::caffe::Phase_IsValid(value)); + set_has_phase(); + phase_ = value; + // @@protoc_insertion_point(field_set:caffe.NetState.phase) +} + +// optional int32 level = 2 [default = 0]; +inline bool NetState::has_level() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void NetState::set_has_level() { + _has_bits_[0] |= 0x00000002u; +} +inline void NetState::clear_has_level() { + _has_bits_[0] &= ~0x00000002u; +} +inline void NetState::clear_level() { + level_ = 0; + clear_has_level(); +} +inline ::google::protobuf::int32 NetState::level() const { + // @@protoc_insertion_point(field_get:caffe.NetState.level) + return level_; +} +inline void NetState::set_level(::google::protobuf::int32 value) { + set_has_level(); + level_ = value; + // @@protoc_insertion_point(field_set:caffe.NetState.level) +} + +// repeated string stage = 3; +inline int NetState::stage_size() const { + return stage_.size(); +} +inline void NetState::clear_stage() { + stage_.Clear(); +} +inline const ::std::string& NetState::stage(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetState.stage) + return stage_.Get(index); +} +inline ::std::string* NetState::mutable_stage(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetState.stage) + return stage_.Mutable(index); +} +inline void NetState::set_stage(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetState.stage) + stage_.Mutable(index)->assign(value); +} +inline void NetState::set_stage(int index, const char* value) { + stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetState.stage) +} +inline void NetState::set_stage(int index, const char* value, size_t size) { + stage_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetState.stage) +} +inline ::std::string* NetState::add_stage() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetState.stage) + return stage_.Add(); +} +inline void NetState::add_stage(const ::std::string& value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetState.stage) +} +inline void NetState::add_stage(const char* value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetState.stage) +} +inline void NetState::add_stage(const char* value, size_t size) { + stage_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetState.stage) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetState::stage() const { + // @@protoc_insertion_point(field_list:caffe.NetState.stage) + return stage_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +NetState::mutable_stage() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetState.stage) + return &stage_; +} + +inline const NetState* NetState::internal_default_instance() { + return &NetState_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NetStateRule + +// optional .caffe.Phase phase = 1; +inline bool NetStateRule::has_phase() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void NetStateRule::set_has_phase() { + _has_bits_[0] |= 0x00000001u; +} +inline void NetStateRule::clear_has_phase() { + _has_bits_[0] &= ~0x00000001u; +} +inline void NetStateRule::clear_phase() { + phase_ = 0; + clear_has_phase(); +} +inline ::caffe::Phase NetStateRule::phase() const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.phase) + return static_cast< ::caffe::Phase >(phase_); +} +inline void NetStateRule::set_phase(::caffe::Phase value) { + assert(::caffe::Phase_IsValid(value)); + set_has_phase(); + phase_ = value; + // @@protoc_insertion_point(field_set:caffe.NetStateRule.phase) +} + +// optional int32 min_level = 2; +inline bool NetStateRule::has_min_level() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void NetStateRule::set_has_min_level() { + _has_bits_[0] |= 0x00000002u; +} +inline void NetStateRule::clear_has_min_level() { + _has_bits_[0] &= ~0x00000002u; +} +inline void NetStateRule::clear_min_level() { + min_level_ = 0; + clear_has_min_level(); +} +inline ::google::protobuf::int32 NetStateRule::min_level() const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.min_level) + return min_level_; +} +inline void NetStateRule::set_min_level(::google::protobuf::int32 value) { + set_has_min_level(); + min_level_ = value; + // @@protoc_insertion_point(field_set:caffe.NetStateRule.min_level) +} + +// optional int32 max_level = 3; +inline bool NetStateRule::has_max_level() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void NetStateRule::set_has_max_level() { + _has_bits_[0] |= 0x00000004u; +} +inline void NetStateRule::clear_has_max_level() { + _has_bits_[0] &= ~0x00000004u; +} +inline void NetStateRule::clear_max_level() { + max_level_ = 0; + clear_has_max_level(); +} +inline ::google::protobuf::int32 NetStateRule::max_level() const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.max_level) + return max_level_; +} +inline void NetStateRule::set_max_level(::google::protobuf::int32 value) { + set_has_max_level(); + max_level_ = value; + // @@protoc_insertion_point(field_set:caffe.NetStateRule.max_level) +} + +// repeated string stage = 4; +inline int NetStateRule::stage_size() const { + return stage_.size(); +} +inline void NetStateRule::clear_stage() { + stage_.Clear(); +} +inline const ::std::string& NetStateRule::stage(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.stage) + return stage_.Get(index); +} +inline ::std::string* NetStateRule::mutable_stage(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetStateRule.stage) + return stage_.Mutable(index); +} +inline void NetStateRule::set_stage(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetStateRule.stage) + stage_.Mutable(index)->assign(value); +} +inline void NetStateRule::set_stage(int index, const char* value) { + stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetStateRule.stage) +} +inline void NetStateRule::set_stage(int index, const char* value, size_t size) { + stage_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetStateRule.stage) +} +inline ::std::string* NetStateRule::add_stage() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetStateRule.stage) + return stage_.Add(); +} +inline void NetStateRule::add_stage(const ::std::string& value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetStateRule.stage) +} +inline void NetStateRule::add_stage(const char* value) { + stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetStateRule.stage) +} +inline void NetStateRule::add_stage(const char* value, size_t size) { + stage_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.stage) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetStateRule::stage() const { + // @@protoc_insertion_point(field_list:caffe.NetStateRule.stage) + return stage_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +NetStateRule::mutable_stage() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetStateRule.stage) + return &stage_; +} + +// repeated string not_stage = 5; +inline int NetStateRule::not_stage_size() const { + return not_stage_.size(); +} +inline void NetStateRule::clear_not_stage() { + not_stage_.Clear(); +} +inline const ::std::string& NetStateRule::not_stage(int index) const { + // @@protoc_insertion_point(field_get:caffe.NetStateRule.not_stage) + return not_stage_.Get(index); +} +inline ::std::string* NetStateRule::mutable_not_stage(int index) { + // @@protoc_insertion_point(field_mutable:caffe.NetStateRule.not_stage) + return not_stage_.Mutable(index); +} +inline void NetStateRule::set_not_stage(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.NetStateRule.not_stage) + not_stage_.Mutable(index)->assign(value); +} +inline void NetStateRule::set_not_stage(int index, const char* value) { + not_stage_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.NetStateRule.not_stage) +} +inline void NetStateRule::set_not_stage(int index, const char* value, size_t size) { + not_stage_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.NetStateRule.not_stage) +} +inline ::std::string* NetStateRule::add_not_stage() { + // @@protoc_insertion_point(field_add_mutable:caffe.NetStateRule.not_stage) + return not_stage_.Add(); +} +inline void NetStateRule::add_not_stage(const ::std::string& value) { + not_stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.NetStateRule.not_stage) +} +inline void NetStateRule::add_not_stage(const char* value) { + not_stage_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.NetStateRule.not_stage) +} +inline void NetStateRule::add_not_stage(const char* value, size_t size) { + not_stage_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.NetStateRule.not_stage) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +NetStateRule::not_stage() const { + // @@protoc_insertion_point(field_list:caffe.NetStateRule.not_stage) + return not_stage_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +NetStateRule::mutable_not_stage() { + // @@protoc_insertion_point(field_mutable_list:caffe.NetStateRule.not_stage) + return ¬_stage_; +} + +inline const NetStateRule* NetStateRule::internal_default_instance() { + return &NetStateRule_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ParamSpec + +// optional string name = 1; +inline bool ParamSpec::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ParamSpec::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void ParamSpec::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ParamSpec::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +inline const ::std::string& ParamSpec::name() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ParamSpec::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ParamSpec.name) +} +inline void ParamSpec::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ParamSpec.name) +} +inline void ParamSpec::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ParamSpec.name) +} +inline ::std::string* ParamSpec::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.ParamSpec.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* ParamSpec::release_name() { + // @@protoc_insertion_point(field_release:caffe.ParamSpec.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ParamSpec::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.ParamSpec.name) +} + +// optional .caffe.ParamSpec.DimCheckMode share_mode = 2; +inline bool ParamSpec::has_share_mode() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ParamSpec::set_has_share_mode() { + _has_bits_[0] |= 0x00000002u; +} +inline void ParamSpec::clear_has_share_mode() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ParamSpec::clear_share_mode() { + share_mode_ = 0; + clear_has_share_mode(); +} +inline ::caffe::ParamSpec_DimCheckMode ParamSpec::share_mode() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.share_mode) + return static_cast< ::caffe::ParamSpec_DimCheckMode >(share_mode_); +} +inline void ParamSpec::set_share_mode(::caffe::ParamSpec_DimCheckMode value) { + assert(::caffe::ParamSpec_DimCheckMode_IsValid(value)); + set_has_share_mode(); + share_mode_ = value; + // @@protoc_insertion_point(field_set:caffe.ParamSpec.share_mode) +} + +// optional float lr_mult = 3 [default = 1]; +inline bool ParamSpec::has_lr_mult() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ParamSpec::set_has_lr_mult() { + _has_bits_[0] |= 0x00000004u; +} +inline void ParamSpec::clear_has_lr_mult() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ParamSpec::clear_lr_mult() { + lr_mult_ = 1; + clear_has_lr_mult(); +} +inline float ParamSpec::lr_mult() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.lr_mult) + return lr_mult_; +} +inline void ParamSpec::set_lr_mult(float value) { + set_has_lr_mult(); + lr_mult_ = value; + // @@protoc_insertion_point(field_set:caffe.ParamSpec.lr_mult) +} + +// optional float decay_mult = 4 [default = 1]; +inline bool ParamSpec::has_decay_mult() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ParamSpec::set_has_decay_mult() { + _has_bits_[0] |= 0x00000008u; +} +inline void ParamSpec::clear_has_decay_mult() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ParamSpec::clear_decay_mult() { + decay_mult_ = 1; + clear_has_decay_mult(); +} +inline float ParamSpec::decay_mult() const { + // @@protoc_insertion_point(field_get:caffe.ParamSpec.decay_mult) + return decay_mult_; +} +inline void ParamSpec::set_decay_mult(float value) { + set_has_decay_mult(); + decay_mult_ = value; + // @@protoc_insertion_point(field_set:caffe.ParamSpec.decay_mult) +} + +inline const ParamSpec* ParamSpec::internal_default_instance() { + return &ParamSpec_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// LayerParameter + +// optional string name = 1; +inline bool LayerParameter::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LayerParameter::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void LayerParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LayerParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +inline const ::std::string& LayerParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void LayerParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.name) +} +inline void LayerParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.name) +} +inline void LayerParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.name) +} +inline ::std::string* LayerParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void LayerParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.name) +} + +// optional string type = 2; +inline bool LayerParameter::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LayerParameter::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void LayerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LayerParameter::clear_type() { + type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_type(); +} +inline const ::std::string& LayerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.type) + return type_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void LayerParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.type) +} +inline void LayerParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.type) +} +inline void LayerParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.type) +} +inline ::std::string* LayerParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.type) + return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* LayerParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void LayerParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type); + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.type) +} + +// repeated string bottom = 3; +inline int LayerParameter::bottom_size() const { + return bottom_.size(); +} +inline void LayerParameter::clear_bottom() { + bottom_.Clear(); +} +inline const ::std::string& LayerParameter::bottom(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.bottom) + return bottom_.Get(index); +} +inline ::std::string* LayerParameter::mutable_bottom(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.bottom) + return bottom_.Mutable(index); +} +inline void LayerParameter::set_bottom(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.LayerParameter.bottom) + bottom_.Mutable(index)->assign(value); +} +inline void LayerParameter::set_bottom(int index, const char* value) { + bottom_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.bottom) +} +inline void LayerParameter::set_bottom(int index, const char* value, size_t size) { + bottom_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.bottom) +} +inline ::std::string* LayerParameter::add_bottom() { + // @@protoc_insertion_point(field_add_mutable:caffe.LayerParameter.bottom) + return bottom_.Add(); +} +inline void LayerParameter::add_bottom(const ::std::string& value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.bottom) +} +inline void LayerParameter::add_bottom(const char* value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.LayerParameter.bottom) +} +inline void LayerParameter::add_bottom(const char* value, size_t size) { + bottom_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.bottom) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +LayerParameter::bottom() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.bottom) + return bottom_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +LayerParameter::mutable_bottom() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.bottom) + return &bottom_; +} + +// repeated string top = 4; +inline int LayerParameter::top_size() const { + return top_.size(); +} +inline void LayerParameter::clear_top() { + top_.Clear(); +} +inline const ::std::string& LayerParameter::top(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.top) + return top_.Get(index); +} +inline ::std::string* LayerParameter::mutable_top(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.top) + return top_.Mutable(index); +} +inline void LayerParameter::set_top(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.LayerParameter.top) + top_.Mutable(index)->assign(value); +} +inline void LayerParameter::set_top(int index, const char* value) { + top_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.LayerParameter.top) +} +inline void LayerParameter::set_top(int index, const char* value, size_t size) { + top_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.LayerParameter.top) +} +inline ::std::string* LayerParameter::add_top() { + // @@protoc_insertion_point(field_add_mutable:caffe.LayerParameter.top) + return top_.Add(); +} +inline void LayerParameter::add_top(const ::std::string& value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.top) +} +inline void LayerParameter::add_top(const char* value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.LayerParameter.top) +} +inline void LayerParameter::add_top(const char* value, size_t size) { + top_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.LayerParameter.top) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +LayerParameter::top() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.top) + return top_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +LayerParameter::mutable_top() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.top) + return &top_; +} + +// optional .caffe.Phase phase = 10; +inline bool LayerParameter::has_phase() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LayerParameter::set_has_phase() { + _has_bits_[0] |= 0x00000010u; +} +inline void LayerParameter::clear_has_phase() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LayerParameter::clear_phase() { + phase_ = 0; + clear_has_phase(); +} +inline ::caffe::Phase LayerParameter::phase() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.phase) + return static_cast< ::caffe::Phase >(phase_); +} +inline void LayerParameter::set_phase(::caffe::Phase value) { + assert(::caffe::Phase_IsValid(value)); + set_has_phase(); + phase_ = value; + // @@protoc_insertion_point(field_set:caffe.LayerParameter.phase) +} + +// repeated float loss_weight = 5; +inline int LayerParameter::loss_weight_size() const { + return loss_weight_.size(); +} +inline void LayerParameter::clear_loss_weight() { + loss_weight_.Clear(); +} +inline float LayerParameter::loss_weight(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.loss_weight) + return loss_weight_.Get(index); +} +inline void LayerParameter::set_loss_weight(int index, float value) { + loss_weight_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.loss_weight) +} +inline void LayerParameter::add_loss_weight(float value) { + loss_weight_.Add(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.loss_weight) +} +inline const ::google::protobuf::RepeatedField< float >& +LayerParameter::loss_weight() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.loss_weight) + return loss_weight_; +} +inline ::google::protobuf::RepeatedField< float >* +LayerParameter::mutable_loss_weight() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.loss_weight) + return &loss_weight_; +} + +// repeated .caffe.ParamSpec param = 6; +inline int LayerParameter::param_size() const { + return param_.size(); +} +inline void LayerParameter::clear_param() { + param_.Clear(); +} +inline const ::caffe::ParamSpec& LayerParameter::param(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.param) + return param_.Get(index); +} +inline ::caffe::ParamSpec* LayerParameter::mutable_param(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.param) + return param_.Mutable(index); +} +inline ::caffe::ParamSpec* LayerParameter::add_param() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.param) + return param_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::ParamSpec >* +LayerParameter::mutable_param() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.param) + return ¶m_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::ParamSpec >& +LayerParameter::param() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.param) + return param_; +} + +// repeated .caffe.BlobProto blobs = 7; +inline int LayerParameter::blobs_size() const { + return blobs_.size(); +} +inline void LayerParameter::clear_blobs() { + blobs_.Clear(); +} +inline const ::caffe::BlobProto& LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.blobs) + return blobs_.Get(index); +} +inline ::caffe::BlobProto* LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.blobs) + return blobs_.Mutable(index); +} +inline ::caffe::BlobProto* LayerParameter::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.blobs) + return blobs_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.blobs) + return &blobs_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +LayerParameter::blobs() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.blobs) + return blobs_; +} + +// repeated bool propagate_down = 11; +inline int LayerParameter::propagate_down_size() const { + return propagate_down_.size(); +} +inline void LayerParameter::clear_propagate_down() { + propagate_down_.Clear(); +} +inline bool LayerParameter::propagate_down(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.propagate_down) + return propagate_down_.Get(index); +} +inline void LayerParameter::set_propagate_down(int index, bool value) { + propagate_down_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.LayerParameter.propagate_down) +} +inline void LayerParameter::add_propagate_down(bool value) { + propagate_down_.Add(value); + // @@protoc_insertion_point(field_add:caffe.LayerParameter.propagate_down) +} +inline const ::google::protobuf::RepeatedField< bool >& +LayerParameter::propagate_down() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.propagate_down) + return propagate_down_; +} +inline ::google::protobuf::RepeatedField< bool >* +LayerParameter::mutable_propagate_down() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.propagate_down) + return &propagate_down_; +} + +// repeated .caffe.NetStateRule include = 8; +inline int LayerParameter::include_size() const { + return include_.size(); +} +inline void LayerParameter::clear_include() { + include_.Clear(); +} +inline const ::caffe::NetStateRule& LayerParameter::include(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.include) + return include_.Get(index); +} +inline ::caffe::NetStateRule* LayerParameter::mutable_include(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.include) + return include_.Mutable(index); +} +inline ::caffe::NetStateRule* LayerParameter::add_include() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.include) + return include_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +LayerParameter::mutable_include() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.include) + return &include_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +LayerParameter::include() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.include) + return include_; +} + +// repeated .caffe.NetStateRule exclude = 9; +inline int LayerParameter::exclude_size() const { + return exclude_.size(); +} +inline void LayerParameter::clear_exclude() { + exclude_.Clear(); +} +inline const ::caffe::NetStateRule& LayerParameter::exclude(int index) const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.exclude) + return exclude_.Get(index); +} +inline ::caffe::NetStateRule* LayerParameter::mutable_exclude(int index) { + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.exclude) + return exclude_.Mutable(index); +} +inline ::caffe::NetStateRule* LayerParameter::add_exclude() { + // @@protoc_insertion_point(field_add:caffe.LayerParameter.exclude) + return exclude_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +LayerParameter::mutable_exclude() { + // @@protoc_insertion_point(field_mutable_list:caffe.LayerParameter.exclude) + return &exclude_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +LayerParameter::exclude() const { + // @@protoc_insertion_point(field_list:caffe.LayerParameter.exclude) + return exclude_; +} + +// optional .caffe.TransformationParameter transform_param = 100; +inline bool LayerParameter::has_transform_param() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void LayerParameter::set_has_transform_param() { + _has_bits_[0] |= 0x00000800u; +} +inline void LayerParameter::clear_has_transform_param() { + _has_bits_[0] &= ~0x00000800u; +} +inline void LayerParameter::clear_transform_param() { + if (transform_param_ != NULL) transform_param_->::caffe::TransformationParameter::Clear(); + clear_has_transform_param(); +} +inline const ::caffe::TransformationParameter& LayerParameter::transform_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.transform_param) + return transform_param_ != NULL ? *transform_param_ + : *::caffe::TransformationParameter::internal_default_instance(); +} +inline ::caffe::TransformationParameter* LayerParameter::mutable_transform_param() { + set_has_transform_param(); + if (transform_param_ == NULL) { + transform_param_ = new ::caffe::TransformationParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.transform_param) + return transform_param_; +} +inline ::caffe::TransformationParameter* LayerParameter::release_transform_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.transform_param) + clear_has_transform_param(); + ::caffe::TransformationParameter* temp = transform_param_; + transform_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_transform_param(::caffe::TransformationParameter* transform_param) { + delete transform_param_; + transform_param_ = transform_param; + if (transform_param) { + set_has_transform_param(); + } else { + clear_has_transform_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.transform_param) +} + +// optional .caffe.LossParameter loss_param = 101; +inline bool LayerParameter::has_loss_param() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void LayerParameter::set_has_loss_param() { + _has_bits_[0] |= 0x00001000u; +} +inline void LayerParameter::clear_has_loss_param() { + _has_bits_[0] &= ~0x00001000u; +} +inline void LayerParameter::clear_loss_param() { + if (loss_param_ != NULL) loss_param_->::caffe::LossParameter::Clear(); + clear_has_loss_param(); +} +inline const ::caffe::LossParameter& LayerParameter::loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.loss_param) + return loss_param_ != NULL ? *loss_param_ + : *::caffe::LossParameter::internal_default_instance(); +} +inline ::caffe::LossParameter* LayerParameter::mutable_loss_param() { + set_has_loss_param(); + if (loss_param_ == NULL) { + loss_param_ = new ::caffe::LossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.loss_param) + return loss_param_; +} +inline ::caffe::LossParameter* LayerParameter::release_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.loss_param) + clear_has_loss_param(); + ::caffe::LossParameter* temp = loss_param_; + loss_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_loss_param(::caffe::LossParameter* loss_param) { + delete loss_param_; + loss_param_ = loss_param; + if (loss_param) { + set_has_loss_param(); + } else { + clear_has_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.loss_param) +} + +// optional .caffe.AccuracyParameter accuracy_param = 102; +inline bool LayerParameter::has_accuracy_param() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void LayerParameter::set_has_accuracy_param() { + _has_bits_[0] |= 0x00002000u; +} +inline void LayerParameter::clear_has_accuracy_param() { + _has_bits_[0] &= ~0x00002000u; +} +inline void LayerParameter::clear_accuracy_param() { + if (accuracy_param_ != NULL) accuracy_param_->::caffe::AccuracyParameter::Clear(); + clear_has_accuracy_param(); +} +inline const ::caffe::AccuracyParameter& LayerParameter::accuracy_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.accuracy_param) + return accuracy_param_ != NULL ? *accuracy_param_ + : *::caffe::AccuracyParameter::internal_default_instance(); +} +inline ::caffe::AccuracyParameter* LayerParameter::mutable_accuracy_param() { + set_has_accuracy_param(); + if (accuracy_param_ == NULL) { + accuracy_param_ = new ::caffe::AccuracyParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.accuracy_param) + return accuracy_param_; +} +inline ::caffe::AccuracyParameter* LayerParameter::release_accuracy_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.accuracy_param) + clear_has_accuracy_param(); + ::caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param) { + delete accuracy_param_; + accuracy_param_ = accuracy_param; + if (accuracy_param) { + set_has_accuracy_param(); + } else { + clear_has_accuracy_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.accuracy_param) +} + +// optional .caffe.ArgMaxParameter argmax_param = 103; +inline bool LayerParameter::has_argmax_param() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void LayerParameter::set_has_argmax_param() { + _has_bits_[0] |= 0x00004000u; +} +inline void LayerParameter::clear_has_argmax_param() { + _has_bits_[0] &= ~0x00004000u; +} +inline void LayerParameter::clear_argmax_param() { + if (argmax_param_ != NULL) argmax_param_->::caffe::ArgMaxParameter::Clear(); + clear_has_argmax_param(); +} +inline const ::caffe::ArgMaxParameter& LayerParameter::argmax_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.argmax_param) + return argmax_param_ != NULL ? *argmax_param_ + : *::caffe::ArgMaxParameter::internal_default_instance(); +} +inline ::caffe::ArgMaxParameter* LayerParameter::mutable_argmax_param() { + set_has_argmax_param(); + if (argmax_param_ == NULL) { + argmax_param_ = new ::caffe::ArgMaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.argmax_param) + return argmax_param_; +} +inline ::caffe::ArgMaxParameter* LayerParameter::release_argmax_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.argmax_param) + clear_has_argmax_param(); + ::caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param) { + delete argmax_param_; + argmax_param_ = argmax_param; + if (argmax_param) { + set_has_argmax_param(); + } else { + clear_has_argmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.argmax_param) +} + +// optional .caffe.BatchNormParameter batch_norm_param = 139; +inline bool LayerParameter::has_batch_norm_param() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void LayerParameter::set_has_batch_norm_param() { + _has_bits_[0] |= 0x00008000u; +} +inline void LayerParameter::clear_has_batch_norm_param() { + _has_bits_[0] &= ~0x00008000u; +} +inline void LayerParameter::clear_batch_norm_param() { + if (batch_norm_param_ != NULL) batch_norm_param_->::caffe::BatchNormParameter::Clear(); + clear_has_batch_norm_param(); +} +inline const ::caffe::BatchNormParameter& LayerParameter::batch_norm_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.batch_norm_param) + return batch_norm_param_ != NULL ? *batch_norm_param_ + : *::caffe::BatchNormParameter::internal_default_instance(); +} +inline ::caffe::BatchNormParameter* LayerParameter::mutable_batch_norm_param() { + set_has_batch_norm_param(); + if (batch_norm_param_ == NULL) { + batch_norm_param_ = new ::caffe::BatchNormParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.batch_norm_param) + return batch_norm_param_; +} +inline ::caffe::BatchNormParameter* LayerParameter::release_batch_norm_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.batch_norm_param) + clear_has_batch_norm_param(); + ::caffe::BatchNormParameter* temp = batch_norm_param_; + batch_norm_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_batch_norm_param(::caffe::BatchNormParameter* batch_norm_param) { + delete batch_norm_param_; + batch_norm_param_ = batch_norm_param; + if (batch_norm_param) { + set_has_batch_norm_param(); + } else { + clear_has_batch_norm_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.batch_norm_param) +} + +// optional .caffe.BiasParameter bias_param = 141; +inline bool LayerParameter::has_bias_param() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +inline void LayerParameter::set_has_bias_param() { + _has_bits_[0] |= 0x00010000u; +} +inline void LayerParameter::clear_has_bias_param() { + _has_bits_[0] &= ~0x00010000u; +} +inline void LayerParameter::clear_bias_param() { + if (bias_param_ != NULL) bias_param_->::caffe::BiasParameter::Clear(); + clear_has_bias_param(); +} +inline const ::caffe::BiasParameter& LayerParameter::bias_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.bias_param) + return bias_param_ != NULL ? *bias_param_ + : *::caffe::BiasParameter::internal_default_instance(); +} +inline ::caffe::BiasParameter* LayerParameter::mutable_bias_param() { + set_has_bias_param(); + if (bias_param_ == NULL) { + bias_param_ = new ::caffe::BiasParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.bias_param) + return bias_param_; +} +inline ::caffe::BiasParameter* LayerParameter::release_bias_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.bias_param) + clear_has_bias_param(); + ::caffe::BiasParameter* temp = bias_param_; + bias_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_bias_param(::caffe::BiasParameter* bias_param) { + delete bias_param_; + bias_param_ = bias_param; + if (bias_param) { + set_has_bias_param(); + } else { + clear_has_bias_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.bias_param) +} + +// optional .caffe.ConcatParameter concat_param = 104; +inline bool LayerParameter::has_concat_param() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +inline void LayerParameter::set_has_concat_param() { + _has_bits_[0] |= 0x00020000u; +} +inline void LayerParameter::clear_has_concat_param() { + _has_bits_[0] &= ~0x00020000u; +} +inline void LayerParameter::clear_concat_param() { + if (concat_param_ != NULL) concat_param_->::caffe::ConcatParameter::Clear(); + clear_has_concat_param(); +} +inline const ::caffe::ConcatParameter& LayerParameter::concat_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.concat_param) + return concat_param_ != NULL ? *concat_param_ + : *::caffe::ConcatParameter::internal_default_instance(); +} +inline ::caffe::ConcatParameter* LayerParameter::mutable_concat_param() { + set_has_concat_param(); + if (concat_param_ == NULL) { + concat_param_ = new ::caffe::ConcatParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.concat_param) + return concat_param_; +} +inline ::caffe::ConcatParameter* LayerParameter::release_concat_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.concat_param) + clear_has_concat_param(); + ::caffe::ConcatParameter* temp = concat_param_; + concat_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_concat_param(::caffe::ConcatParameter* concat_param) { + delete concat_param_; + concat_param_ = concat_param; + if (concat_param) { + set_has_concat_param(); + } else { + clear_has_concat_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.concat_param) +} + +// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 105; +inline bool LayerParameter::has_contrastive_loss_param() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +inline void LayerParameter::set_has_contrastive_loss_param() { + _has_bits_[0] |= 0x00040000u; +} +inline void LayerParameter::clear_has_contrastive_loss_param() { + _has_bits_[0] &= ~0x00040000u; +} +inline void LayerParameter::clear_contrastive_loss_param() { + if (contrastive_loss_param_ != NULL) contrastive_loss_param_->::caffe::ContrastiveLossParameter::Clear(); + clear_has_contrastive_loss_param(); +} +inline const ::caffe::ContrastiveLossParameter& LayerParameter::contrastive_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.contrastive_loss_param) + return contrastive_loss_param_ != NULL ? *contrastive_loss_param_ + : *::caffe::ContrastiveLossParameter::internal_default_instance(); +} +inline ::caffe::ContrastiveLossParameter* LayerParameter::mutable_contrastive_loss_param() { + set_has_contrastive_loss_param(); + if (contrastive_loss_param_ == NULL) { + contrastive_loss_param_ = new ::caffe::ContrastiveLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.contrastive_loss_param) + return contrastive_loss_param_; +} +inline ::caffe::ContrastiveLossParameter* LayerParameter::release_contrastive_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.contrastive_loss_param) + clear_has_contrastive_loss_param(); + ::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param) { + delete contrastive_loss_param_; + contrastive_loss_param_ = contrastive_loss_param; + if (contrastive_loss_param) { + set_has_contrastive_loss_param(); + } else { + clear_has_contrastive_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.contrastive_loss_param) +} + +// optional .caffe.ConvolutionParameter convolution_param = 106; +inline bool LayerParameter::has_convolution_param() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +inline void LayerParameter::set_has_convolution_param() { + _has_bits_[0] |= 0x00080000u; +} +inline void LayerParameter::clear_has_convolution_param() { + _has_bits_[0] &= ~0x00080000u; +} +inline void LayerParameter::clear_convolution_param() { + if (convolution_param_ != NULL) convolution_param_->::caffe::ConvolutionParameter::Clear(); + clear_has_convolution_param(); +} +inline const ::caffe::ConvolutionParameter& LayerParameter::convolution_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.convolution_param) + return convolution_param_ != NULL ? *convolution_param_ + : *::caffe::ConvolutionParameter::internal_default_instance(); +} +inline ::caffe::ConvolutionParameter* LayerParameter::mutable_convolution_param() { + set_has_convolution_param(); + if (convolution_param_ == NULL) { + convolution_param_ = new ::caffe::ConvolutionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.convolution_param) + return convolution_param_; +} +inline ::caffe::ConvolutionParameter* LayerParameter::release_convolution_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.convolution_param) + clear_has_convolution_param(); + ::caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param) { + delete convolution_param_; + convolution_param_ = convolution_param; + if (convolution_param) { + set_has_convolution_param(); + } else { + clear_has_convolution_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.convolution_param) +} + +// optional .caffe.CropParameter crop_param = 144; +inline bool LayerParameter::has_crop_param() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +inline void LayerParameter::set_has_crop_param() { + _has_bits_[0] |= 0x00100000u; +} +inline void LayerParameter::clear_has_crop_param() { + _has_bits_[0] &= ~0x00100000u; +} +inline void LayerParameter::clear_crop_param() { + if (crop_param_ != NULL) crop_param_->::caffe::CropParameter::Clear(); + clear_has_crop_param(); +} +inline const ::caffe::CropParameter& LayerParameter::crop_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.crop_param) + return crop_param_ != NULL ? *crop_param_ + : *::caffe::CropParameter::internal_default_instance(); +} +inline ::caffe::CropParameter* LayerParameter::mutable_crop_param() { + set_has_crop_param(); + if (crop_param_ == NULL) { + crop_param_ = new ::caffe::CropParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.crop_param) + return crop_param_; +} +inline ::caffe::CropParameter* LayerParameter::release_crop_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.crop_param) + clear_has_crop_param(); + ::caffe::CropParameter* temp = crop_param_; + crop_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_crop_param(::caffe::CropParameter* crop_param) { + delete crop_param_; + crop_param_ = crop_param; + if (crop_param) { + set_has_crop_param(); + } else { + clear_has_crop_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.crop_param) +} + +// optional .caffe.DataParameter data_param = 107; +inline bool LayerParameter::has_data_param() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +inline void LayerParameter::set_has_data_param() { + _has_bits_[0] |= 0x00200000u; +} +inline void LayerParameter::clear_has_data_param() { + _has_bits_[0] &= ~0x00200000u; +} +inline void LayerParameter::clear_data_param() { + if (data_param_ != NULL) data_param_->::caffe::DataParameter::Clear(); + clear_has_data_param(); +} +inline const ::caffe::DataParameter& LayerParameter::data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.data_param) + return data_param_ != NULL ? *data_param_ + : *::caffe::DataParameter::internal_default_instance(); +} +inline ::caffe::DataParameter* LayerParameter::mutable_data_param() { + set_has_data_param(); + if (data_param_ == NULL) { + data_param_ = new ::caffe::DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.data_param) + return data_param_; +} +inline ::caffe::DataParameter* LayerParameter::release_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.data_param) + clear_has_data_param(); + ::caffe::DataParameter* temp = data_param_; + data_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_data_param(::caffe::DataParameter* data_param) { + delete data_param_; + data_param_ = data_param; + if (data_param) { + set_has_data_param(); + } else { + clear_has_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.data_param) +} + +// optional .caffe.DetectionOutputParameter detection_output_param = 147; +inline bool LayerParameter::has_detection_output_param() const { + return (_has_bits_[0] & 0x00400000u) != 0; +} +inline void LayerParameter::set_has_detection_output_param() { + _has_bits_[0] |= 0x00400000u; +} +inline void LayerParameter::clear_has_detection_output_param() { + _has_bits_[0] &= ~0x00400000u; +} +inline void LayerParameter::clear_detection_output_param() { + if (detection_output_param_ != NULL) detection_output_param_->::caffe::DetectionOutputParameter::Clear(); + clear_has_detection_output_param(); +} +inline const ::caffe::DetectionOutputParameter& LayerParameter::detection_output_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.detection_output_param) + return detection_output_param_ != NULL ? *detection_output_param_ + : *::caffe::DetectionOutputParameter::internal_default_instance(); +} +inline ::caffe::DetectionOutputParameter* LayerParameter::mutable_detection_output_param() { + set_has_detection_output_param(); + if (detection_output_param_ == NULL) { + detection_output_param_ = new ::caffe::DetectionOutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.detection_output_param) + return detection_output_param_; +} +inline ::caffe::DetectionOutputParameter* LayerParameter::release_detection_output_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.detection_output_param) + clear_has_detection_output_param(); + ::caffe::DetectionOutputParameter* temp = detection_output_param_; + detection_output_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_detection_output_param(::caffe::DetectionOutputParameter* detection_output_param) { + delete detection_output_param_; + detection_output_param_ = detection_output_param; + if (detection_output_param) { + set_has_detection_output_param(); + } else { + clear_has_detection_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.detection_output_param) +} + +// optional .caffe.DropoutParameter dropout_param = 108; +inline bool LayerParameter::has_dropout_param() const { + return (_has_bits_[0] & 0x00800000u) != 0; +} +inline void LayerParameter::set_has_dropout_param() { + _has_bits_[0] |= 0x00800000u; +} +inline void LayerParameter::clear_has_dropout_param() { + _has_bits_[0] &= ~0x00800000u; +} +inline void LayerParameter::clear_dropout_param() { + if (dropout_param_ != NULL) dropout_param_->::caffe::DropoutParameter::Clear(); + clear_has_dropout_param(); +} +inline const ::caffe::DropoutParameter& LayerParameter::dropout_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.dropout_param) + return dropout_param_ != NULL ? *dropout_param_ + : *::caffe::DropoutParameter::internal_default_instance(); +} +inline ::caffe::DropoutParameter* LayerParameter::mutable_dropout_param() { + set_has_dropout_param(); + if (dropout_param_ == NULL) { + dropout_param_ = new ::caffe::DropoutParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.dropout_param) + return dropout_param_; +} +inline ::caffe::DropoutParameter* LayerParameter::release_dropout_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.dropout_param) + clear_has_dropout_param(); + ::caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param) { + delete dropout_param_; + dropout_param_ = dropout_param; + if (dropout_param) { + set_has_dropout_param(); + } else { + clear_has_dropout_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.dropout_param) +} + +// optional .caffe.DummyDataParameter dummy_data_param = 109; +inline bool LayerParameter::has_dummy_data_param() const { + return (_has_bits_[0] & 0x01000000u) != 0; +} +inline void LayerParameter::set_has_dummy_data_param() { + _has_bits_[0] |= 0x01000000u; +} +inline void LayerParameter::clear_has_dummy_data_param() { + _has_bits_[0] &= ~0x01000000u; +} +inline void LayerParameter::clear_dummy_data_param() { + if (dummy_data_param_ != NULL) dummy_data_param_->::caffe::DummyDataParameter::Clear(); + clear_has_dummy_data_param(); +} +inline const ::caffe::DummyDataParameter& LayerParameter::dummy_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.dummy_data_param) + return dummy_data_param_ != NULL ? *dummy_data_param_ + : *::caffe::DummyDataParameter::internal_default_instance(); +} +inline ::caffe::DummyDataParameter* LayerParameter::mutable_dummy_data_param() { + set_has_dummy_data_param(); + if (dummy_data_param_ == NULL) { + dummy_data_param_ = new ::caffe::DummyDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.dummy_data_param) + return dummy_data_param_; +} +inline ::caffe::DummyDataParameter* LayerParameter::release_dummy_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.dummy_data_param) + clear_has_dummy_data_param(); + ::caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param) { + delete dummy_data_param_; + dummy_data_param_ = dummy_data_param; + if (dummy_data_param) { + set_has_dummy_data_param(); + } else { + clear_has_dummy_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.dummy_data_param) +} + +// optional .caffe.EltwiseParameter eltwise_param = 110; +inline bool LayerParameter::has_eltwise_param() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +inline void LayerParameter::set_has_eltwise_param() { + _has_bits_[0] |= 0x02000000u; +} +inline void LayerParameter::clear_has_eltwise_param() { + _has_bits_[0] &= ~0x02000000u; +} +inline void LayerParameter::clear_eltwise_param() { + if (eltwise_param_ != NULL) eltwise_param_->::caffe::EltwiseParameter::Clear(); + clear_has_eltwise_param(); +} +inline const ::caffe::EltwiseParameter& LayerParameter::eltwise_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.eltwise_param) + return eltwise_param_ != NULL ? *eltwise_param_ + : *::caffe::EltwiseParameter::internal_default_instance(); +} +inline ::caffe::EltwiseParameter* LayerParameter::mutable_eltwise_param() { + set_has_eltwise_param(); + if (eltwise_param_ == NULL) { + eltwise_param_ = new ::caffe::EltwiseParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.eltwise_param) + return eltwise_param_; +} +inline ::caffe::EltwiseParameter* LayerParameter::release_eltwise_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.eltwise_param) + clear_has_eltwise_param(); + ::caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param) { + delete eltwise_param_; + eltwise_param_ = eltwise_param; + if (eltwise_param) { + set_has_eltwise_param(); + } else { + clear_has_eltwise_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.eltwise_param) +} + +// optional .caffe.ELUParameter elu_param = 140; +inline bool LayerParameter::has_elu_param() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +inline void LayerParameter::set_has_elu_param() { + _has_bits_[0] |= 0x04000000u; +} +inline void LayerParameter::clear_has_elu_param() { + _has_bits_[0] &= ~0x04000000u; +} +inline void LayerParameter::clear_elu_param() { + if (elu_param_ != NULL) elu_param_->::caffe::ELUParameter::Clear(); + clear_has_elu_param(); +} +inline const ::caffe::ELUParameter& LayerParameter::elu_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.elu_param) + return elu_param_ != NULL ? *elu_param_ + : *::caffe::ELUParameter::internal_default_instance(); +} +inline ::caffe::ELUParameter* LayerParameter::mutable_elu_param() { + set_has_elu_param(); + if (elu_param_ == NULL) { + elu_param_ = new ::caffe::ELUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.elu_param) + return elu_param_; +} +inline ::caffe::ELUParameter* LayerParameter::release_elu_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.elu_param) + clear_has_elu_param(); + ::caffe::ELUParameter* temp = elu_param_; + elu_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_elu_param(::caffe::ELUParameter* elu_param) { + delete elu_param_; + elu_param_ = elu_param; + if (elu_param) { + set_has_elu_param(); + } else { + clear_has_elu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.elu_param) +} + +// optional .caffe.EmbedParameter embed_param = 137; +inline bool LayerParameter::has_embed_param() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +inline void LayerParameter::set_has_embed_param() { + _has_bits_[0] |= 0x08000000u; +} +inline void LayerParameter::clear_has_embed_param() { + _has_bits_[0] &= ~0x08000000u; +} +inline void LayerParameter::clear_embed_param() { + if (embed_param_ != NULL) embed_param_->::caffe::EmbedParameter::Clear(); + clear_has_embed_param(); +} +inline const ::caffe::EmbedParameter& LayerParameter::embed_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.embed_param) + return embed_param_ != NULL ? *embed_param_ + : *::caffe::EmbedParameter::internal_default_instance(); +} +inline ::caffe::EmbedParameter* LayerParameter::mutable_embed_param() { + set_has_embed_param(); + if (embed_param_ == NULL) { + embed_param_ = new ::caffe::EmbedParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.embed_param) + return embed_param_; +} +inline ::caffe::EmbedParameter* LayerParameter::release_embed_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.embed_param) + clear_has_embed_param(); + ::caffe::EmbedParameter* temp = embed_param_; + embed_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_embed_param(::caffe::EmbedParameter* embed_param) { + delete embed_param_; + embed_param_ = embed_param; + if (embed_param) { + set_has_embed_param(); + } else { + clear_has_embed_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.embed_param) +} + +// optional .caffe.ExpParameter exp_param = 111; +inline bool LayerParameter::has_exp_param() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +inline void LayerParameter::set_has_exp_param() { + _has_bits_[0] |= 0x10000000u; +} +inline void LayerParameter::clear_has_exp_param() { + _has_bits_[0] &= ~0x10000000u; +} +inline void LayerParameter::clear_exp_param() { + if (exp_param_ != NULL) exp_param_->::caffe::ExpParameter::Clear(); + clear_has_exp_param(); +} +inline const ::caffe::ExpParameter& LayerParameter::exp_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.exp_param) + return exp_param_ != NULL ? *exp_param_ + : *::caffe::ExpParameter::internal_default_instance(); +} +inline ::caffe::ExpParameter* LayerParameter::mutable_exp_param() { + set_has_exp_param(); + if (exp_param_ == NULL) { + exp_param_ = new ::caffe::ExpParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.exp_param) + return exp_param_; +} +inline ::caffe::ExpParameter* LayerParameter::release_exp_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.exp_param) + clear_has_exp_param(); + ::caffe::ExpParameter* temp = exp_param_; + exp_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_exp_param(::caffe::ExpParameter* exp_param) { + delete exp_param_; + exp_param_ = exp_param; + if (exp_param) { + set_has_exp_param(); + } else { + clear_has_exp_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.exp_param) +} + +// optional .caffe.FlattenParameter flatten_param = 135; +inline bool LayerParameter::has_flatten_param() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +inline void LayerParameter::set_has_flatten_param() { + _has_bits_[0] |= 0x20000000u; +} +inline void LayerParameter::clear_has_flatten_param() { + _has_bits_[0] &= ~0x20000000u; +} +inline void LayerParameter::clear_flatten_param() { + if (flatten_param_ != NULL) flatten_param_->::caffe::FlattenParameter::Clear(); + clear_has_flatten_param(); +} +inline const ::caffe::FlattenParameter& LayerParameter::flatten_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.flatten_param) + return flatten_param_ != NULL ? *flatten_param_ + : *::caffe::FlattenParameter::internal_default_instance(); +} +inline ::caffe::FlattenParameter* LayerParameter::mutable_flatten_param() { + set_has_flatten_param(); + if (flatten_param_ == NULL) { + flatten_param_ = new ::caffe::FlattenParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.flatten_param) + return flatten_param_; +} +inline ::caffe::FlattenParameter* LayerParameter::release_flatten_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.flatten_param) + clear_has_flatten_param(); + ::caffe::FlattenParameter* temp = flatten_param_; + flatten_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_flatten_param(::caffe::FlattenParameter* flatten_param) { + delete flatten_param_; + flatten_param_ = flatten_param; + if (flatten_param) { + set_has_flatten_param(); + } else { + clear_has_flatten_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.flatten_param) +} + +// optional .caffe.HDF5DataParameter hdf5_data_param = 112; +inline bool LayerParameter::has_hdf5_data_param() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +inline void LayerParameter::set_has_hdf5_data_param() { + _has_bits_[0] |= 0x40000000u; +} +inline void LayerParameter::clear_has_hdf5_data_param() { + _has_bits_[0] &= ~0x40000000u; +} +inline void LayerParameter::clear_hdf5_data_param() { + if (hdf5_data_param_ != NULL) hdf5_data_param_->::caffe::HDF5DataParameter::Clear(); + clear_has_hdf5_data_param(); +} +inline const ::caffe::HDF5DataParameter& LayerParameter::hdf5_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.hdf5_data_param) + return hdf5_data_param_ != NULL ? *hdf5_data_param_ + : *::caffe::HDF5DataParameter::internal_default_instance(); +} +inline ::caffe::HDF5DataParameter* LayerParameter::mutable_hdf5_data_param() { + set_has_hdf5_data_param(); + if (hdf5_data_param_ == NULL) { + hdf5_data_param_ = new ::caffe::HDF5DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hdf5_data_param) + return hdf5_data_param_; +} +inline ::caffe::HDF5DataParameter* LayerParameter::release_hdf5_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.hdf5_data_param) + clear_has_hdf5_data_param(); + ::caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param) { + delete hdf5_data_param_; + hdf5_data_param_ = hdf5_data_param; + if (hdf5_data_param) { + set_has_hdf5_data_param(); + } else { + clear_has_hdf5_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hdf5_data_param) +} + +// optional .caffe.HDF5OutputParameter hdf5_output_param = 113; +inline bool LayerParameter::has_hdf5_output_param() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +inline void LayerParameter::set_has_hdf5_output_param() { + _has_bits_[0] |= 0x80000000u; +} +inline void LayerParameter::clear_has_hdf5_output_param() { + _has_bits_[0] &= ~0x80000000u; +} +inline void LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + clear_has_hdf5_output_param(); +} +inline const ::caffe::HDF5OutputParameter& LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.hdf5_output_param) + return hdf5_output_param_ != NULL ? *hdf5_output_param_ + : *::caffe::HDF5OutputParameter::internal_default_instance(); +} +inline ::caffe::HDF5OutputParameter* LayerParameter::mutable_hdf5_output_param() { + set_has_hdf5_output_param(); + if (hdf5_output_param_ == NULL) { + hdf5_output_param_ = new ::caffe::HDF5OutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hdf5_output_param) + return hdf5_output_param_; +} +inline ::caffe::HDF5OutputParameter* LayerParameter::release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.hdf5_output_param) + clear_has_hdf5_output_param(); + ::caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) { + delete hdf5_output_param_; + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + set_has_hdf5_output_param(); + } else { + clear_has_hdf5_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hdf5_output_param) +} + +// optional .caffe.HingeLossParameter hinge_loss_param = 114; +inline bool LayerParameter::has_hinge_loss_param() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +inline void LayerParameter::set_has_hinge_loss_param() { + _has_bits_[1] |= 0x00000001u; +} +inline void LayerParameter::clear_has_hinge_loss_param() { + _has_bits_[1] &= ~0x00000001u; +} +inline void LayerParameter::clear_hinge_loss_param() { + if (hinge_loss_param_ != NULL) hinge_loss_param_->::caffe::HingeLossParameter::Clear(); + clear_has_hinge_loss_param(); +} +inline const ::caffe::HingeLossParameter& LayerParameter::hinge_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.hinge_loss_param) + return hinge_loss_param_ != NULL ? *hinge_loss_param_ + : *::caffe::HingeLossParameter::internal_default_instance(); +} +inline ::caffe::HingeLossParameter* LayerParameter::mutable_hinge_loss_param() { + set_has_hinge_loss_param(); + if (hinge_loss_param_ == NULL) { + hinge_loss_param_ = new ::caffe::HingeLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.hinge_loss_param) + return hinge_loss_param_; +} +inline ::caffe::HingeLossParameter* LayerParameter::release_hinge_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.hinge_loss_param) + clear_has_hinge_loss_param(); + ::caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param) { + delete hinge_loss_param_; + hinge_loss_param_ = hinge_loss_param; + if (hinge_loss_param) { + set_has_hinge_loss_param(); + } else { + clear_has_hinge_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.hinge_loss_param) +} + +// optional .caffe.ImageDataParameter image_data_param = 115; +inline bool LayerParameter::has_image_data_param() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +inline void LayerParameter::set_has_image_data_param() { + _has_bits_[1] |= 0x00000002u; +} +inline void LayerParameter::clear_has_image_data_param() { + _has_bits_[1] &= ~0x00000002u; +} +inline void LayerParameter::clear_image_data_param() { + if (image_data_param_ != NULL) image_data_param_->::caffe::ImageDataParameter::Clear(); + clear_has_image_data_param(); +} +inline const ::caffe::ImageDataParameter& LayerParameter::image_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.image_data_param) + return image_data_param_ != NULL ? *image_data_param_ + : *::caffe::ImageDataParameter::internal_default_instance(); +} +inline ::caffe::ImageDataParameter* LayerParameter::mutable_image_data_param() { + set_has_image_data_param(); + if (image_data_param_ == NULL) { + image_data_param_ = new ::caffe::ImageDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.image_data_param) + return image_data_param_; +} +inline ::caffe::ImageDataParameter* LayerParameter::release_image_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.image_data_param) + clear_has_image_data_param(); + ::caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param) { + delete image_data_param_; + image_data_param_ = image_data_param; + if (image_data_param) { + set_has_image_data_param(); + } else { + clear_has_image_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.image_data_param) +} + +// optional .caffe.InfogainLossParameter infogain_loss_param = 116; +inline bool LayerParameter::has_infogain_loss_param() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +inline void LayerParameter::set_has_infogain_loss_param() { + _has_bits_[1] |= 0x00000004u; +} +inline void LayerParameter::clear_has_infogain_loss_param() { + _has_bits_[1] &= ~0x00000004u; +} +inline void LayerParameter::clear_infogain_loss_param() { + if (infogain_loss_param_ != NULL) infogain_loss_param_->::caffe::InfogainLossParameter::Clear(); + clear_has_infogain_loss_param(); +} +inline const ::caffe::InfogainLossParameter& LayerParameter::infogain_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.infogain_loss_param) + return infogain_loss_param_ != NULL ? *infogain_loss_param_ + : *::caffe::InfogainLossParameter::internal_default_instance(); +} +inline ::caffe::InfogainLossParameter* LayerParameter::mutable_infogain_loss_param() { + set_has_infogain_loss_param(); + if (infogain_loss_param_ == NULL) { + infogain_loss_param_ = new ::caffe::InfogainLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.infogain_loss_param) + return infogain_loss_param_; +} +inline ::caffe::InfogainLossParameter* LayerParameter::release_infogain_loss_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.infogain_loss_param) + clear_has_infogain_loss_param(); + ::caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param) { + delete infogain_loss_param_; + infogain_loss_param_ = infogain_loss_param; + if (infogain_loss_param) { + set_has_infogain_loss_param(); + } else { + clear_has_infogain_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.infogain_loss_param) +} + +// optional .caffe.InnerProductParameter inner_product_param = 117; +inline bool LayerParameter::has_inner_product_param() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +inline void LayerParameter::set_has_inner_product_param() { + _has_bits_[1] |= 0x00000008u; +} +inline void LayerParameter::clear_has_inner_product_param() { + _has_bits_[1] &= ~0x00000008u; +} +inline void LayerParameter::clear_inner_product_param() { + if (inner_product_param_ != NULL) inner_product_param_->::caffe::InnerProductParameter::Clear(); + clear_has_inner_product_param(); +} +inline const ::caffe::InnerProductParameter& LayerParameter::inner_product_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.inner_product_param) + return inner_product_param_ != NULL ? *inner_product_param_ + : *::caffe::InnerProductParameter::internal_default_instance(); +} +inline ::caffe::InnerProductParameter* LayerParameter::mutable_inner_product_param() { + set_has_inner_product_param(); + if (inner_product_param_ == NULL) { + inner_product_param_ = new ::caffe::InnerProductParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.inner_product_param) + return inner_product_param_; +} +inline ::caffe::InnerProductParameter* LayerParameter::release_inner_product_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.inner_product_param) + clear_has_inner_product_param(); + ::caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param) { + delete inner_product_param_; + inner_product_param_ = inner_product_param; + if (inner_product_param) { + set_has_inner_product_param(); + } else { + clear_has_inner_product_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.inner_product_param) +} + +// optional .caffe.InputParameter input_param = 143; +inline bool LayerParameter::has_input_param() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +inline void LayerParameter::set_has_input_param() { + _has_bits_[1] |= 0x00000010u; +} +inline void LayerParameter::clear_has_input_param() { + _has_bits_[1] &= ~0x00000010u; +} +inline void LayerParameter::clear_input_param() { + if (input_param_ != NULL) input_param_->::caffe::InputParameter::Clear(); + clear_has_input_param(); +} +inline const ::caffe::InputParameter& LayerParameter::input_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.input_param) + return input_param_ != NULL ? *input_param_ + : *::caffe::InputParameter::internal_default_instance(); +} +inline ::caffe::InputParameter* LayerParameter::mutable_input_param() { + set_has_input_param(); + if (input_param_ == NULL) { + input_param_ = new ::caffe::InputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.input_param) + return input_param_; +} +inline ::caffe::InputParameter* LayerParameter::release_input_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.input_param) + clear_has_input_param(); + ::caffe::InputParameter* temp = input_param_; + input_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_input_param(::caffe::InputParameter* input_param) { + delete input_param_; + input_param_ = input_param; + if (input_param) { + set_has_input_param(); + } else { + clear_has_input_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.input_param) +} + +// optional .caffe.LogParameter log_param = 134; +inline bool LayerParameter::has_log_param() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +inline void LayerParameter::set_has_log_param() { + _has_bits_[1] |= 0x00000020u; +} +inline void LayerParameter::clear_has_log_param() { + _has_bits_[1] &= ~0x00000020u; +} +inline void LayerParameter::clear_log_param() { + if (log_param_ != NULL) log_param_->::caffe::LogParameter::Clear(); + clear_has_log_param(); +} +inline const ::caffe::LogParameter& LayerParameter::log_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.log_param) + return log_param_ != NULL ? *log_param_ + : *::caffe::LogParameter::internal_default_instance(); +} +inline ::caffe::LogParameter* LayerParameter::mutable_log_param() { + set_has_log_param(); + if (log_param_ == NULL) { + log_param_ = new ::caffe::LogParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.log_param) + return log_param_; +} +inline ::caffe::LogParameter* LayerParameter::release_log_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.log_param) + clear_has_log_param(); + ::caffe::LogParameter* temp = log_param_; + log_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_log_param(::caffe::LogParameter* log_param) { + delete log_param_; + log_param_ = log_param; + if (log_param) { + set_has_log_param(); + } else { + clear_has_log_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.log_param) +} + +// optional .caffe.LRNParameter lrn_param = 118; +inline bool LayerParameter::has_lrn_param() const { + return (_has_bits_[1] & 0x00000040u) != 0; +} +inline void LayerParameter::set_has_lrn_param() { + _has_bits_[1] |= 0x00000040u; +} +inline void LayerParameter::clear_has_lrn_param() { + _has_bits_[1] &= ~0x00000040u; +} +inline void LayerParameter::clear_lrn_param() { + if (lrn_param_ != NULL) lrn_param_->::caffe::LRNParameter::Clear(); + clear_has_lrn_param(); +} +inline const ::caffe::LRNParameter& LayerParameter::lrn_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.lrn_param) + return lrn_param_ != NULL ? *lrn_param_ + : *::caffe::LRNParameter::internal_default_instance(); +} +inline ::caffe::LRNParameter* LayerParameter::mutable_lrn_param() { + set_has_lrn_param(); + if (lrn_param_ == NULL) { + lrn_param_ = new ::caffe::LRNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.lrn_param) + return lrn_param_; +} +inline ::caffe::LRNParameter* LayerParameter::release_lrn_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.lrn_param) + clear_has_lrn_param(); + ::caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_lrn_param(::caffe::LRNParameter* lrn_param) { + delete lrn_param_; + lrn_param_ = lrn_param; + if (lrn_param) { + set_has_lrn_param(); + } else { + clear_has_lrn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.lrn_param) +} + +// optional .caffe.MemoryDataParameter memory_data_param = 119; +inline bool LayerParameter::has_memory_data_param() const { + return (_has_bits_[1] & 0x00000080u) != 0; +} +inline void LayerParameter::set_has_memory_data_param() { + _has_bits_[1] |= 0x00000080u; +} +inline void LayerParameter::clear_has_memory_data_param() { + _has_bits_[1] &= ~0x00000080u; +} +inline void LayerParameter::clear_memory_data_param() { + if (memory_data_param_ != NULL) memory_data_param_->::caffe::MemoryDataParameter::Clear(); + clear_has_memory_data_param(); +} +inline const ::caffe::MemoryDataParameter& LayerParameter::memory_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.memory_data_param) + return memory_data_param_ != NULL ? *memory_data_param_ + : *::caffe::MemoryDataParameter::internal_default_instance(); +} +inline ::caffe::MemoryDataParameter* LayerParameter::mutable_memory_data_param() { + set_has_memory_data_param(); + if (memory_data_param_ == NULL) { + memory_data_param_ = new ::caffe::MemoryDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.memory_data_param) + return memory_data_param_; +} +inline ::caffe::MemoryDataParameter* LayerParameter::release_memory_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.memory_data_param) + clear_has_memory_data_param(); + ::caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param) { + delete memory_data_param_; + memory_data_param_ = memory_data_param; + if (memory_data_param) { + set_has_memory_data_param(); + } else { + clear_has_memory_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.memory_data_param) +} + +// optional .caffe.MVNParameter mvn_param = 120; +inline bool LayerParameter::has_mvn_param() const { + return (_has_bits_[1] & 0x00000100u) != 0; +} +inline void LayerParameter::set_has_mvn_param() { + _has_bits_[1] |= 0x00000100u; +} +inline void LayerParameter::clear_has_mvn_param() { + _has_bits_[1] &= ~0x00000100u; +} +inline void LayerParameter::clear_mvn_param() { + if (mvn_param_ != NULL) mvn_param_->::caffe::MVNParameter::Clear(); + clear_has_mvn_param(); +} +inline const ::caffe::MVNParameter& LayerParameter::mvn_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.mvn_param) + return mvn_param_ != NULL ? *mvn_param_ + : *::caffe::MVNParameter::internal_default_instance(); +} +inline ::caffe::MVNParameter* LayerParameter::mutable_mvn_param() { + set_has_mvn_param(); + if (mvn_param_ == NULL) { + mvn_param_ = new ::caffe::MVNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.mvn_param) + return mvn_param_; +} +inline ::caffe::MVNParameter* LayerParameter::release_mvn_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.mvn_param) + clear_has_mvn_param(); + ::caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_mvn_param(::caffe::MVNParameter* mvn_param) { + delete mvn_param_; + mvn_param_ = mvn_param; + if (mvn_param) { + set_has_mvn_param(); + } else { + clear_has_mvn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.mvn_param) +} + +// optional .caffe.NormalizeBBoxParameter norm_param = 149; +inline bool LayerParameter::has_norm_param() const { + return (_has_bits_[1] & 0x00000200u) != 0; +} +inline void LayerParameter::set_has_norm_param() { + _has_bits_[1] |= 0x00000200u; +} +inline void LayerParameter::clear_has_norm_param() { + _has_bits_[1] &= ~0x00000200u; +} +inline void LayerParameter::clear_norm_param() { + if (norm_param_ != NULL) norm_param_->::caffe::NormalizeBBoxParameter::Clear(); + clear_has_norm_param(); +} +inline const ::caffe::NormalizeBBoxParameter& LayerParameter::norm_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.norm_param) + return norm_param_ != NULL ? *norm_param_ + : *::caffe::NormalizeBBoxParameter::internal_default_instance(); +} +inline ::caffe::NormalizeBBoxParameter* LayerParameter::mutable_norm_param() { + set_has_norm_param(); + if (norm_param_ == NULL) { + norm_param_ = new ::caffe::NormalizeBBoxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.norm_param) + return norm_param_; +} +inline ::caffe::NormalizeBBoxParameter* LayerParameter::release_norm_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.norm_param) + clear_has_norm_param(); + ::caffe::NormalizeBBoxParameter* temp = norm_param_; + norm_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_norm_param(::caffe::NormalizeBBoxParameter* norm_param) { + delete norm_param_; + norm_param_ = norm_param; + if (norm_param) { + set_has_norm_param(); + } else { + clear_has_norm_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.norm_param) +} + +// optional .caffe.PermuteParameter permute_param = 148; +inline bool LayerParameter::has_permute_param() const { + return (_has_bits_[1] & 0x00000400u) != 0; +} +inline void LayerParameter::set_has_permute_param() { + _has_bits_[1] |= 0x00000400u; +} +inline void LayerParameter::clear_has_permute_param() { + _has_bits_[1] &= ~0x00000400u; +} +inline void LayerParameter::clear_permute_param() { + if (permute_param_ != NULL) permute_param_->::caffe::PermuteParameter::Clear(); + clear_has_permute_param(); +} +inline const ::caffe::PermuteParameter& LayerParameter::permute_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.permute_param) + return permute_param_ != NULL ? *permute_param_ + : *::caffe::PermuteParameter::internal_default_instance(); +} +inline ::caffe::PermuteParameter* LayerParameter::mutable_permute_param() { + set_has_permute_param(); + if (permute_param_ == NULL) { + permute_param_ = new ::caffe::PermuteParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.permute_param) + return permute_param_; +} +inline ::caffe::PermuteParameter* LayerParameter::release_permute_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.permute_param) + clear_has_permute_param(); + ::caffe::PermuteParameter* temp = permute_param_; + permute_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_permute_param(::caffe::PermuteParameter* permute_param) { + delete permute_param_; + permute_param_ = permute_param; + if (permute_param) { + set_has_permute_param(); + } else { + clear_has_permute_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.permute_param) +} + +// optional .caffe.ParameterParameter parameter_param = 145; +inline bool LayerParameter::has_parameter_param() const { + return (_has_bits_[1] & 0x00000800u) != 0; +} +inline void LayerParameter::set_has_parameter_param() { + _has_bits_[1] |= 0x00000800u; +} +inline void LayerParameter::clear_has_parameter_param() { + _has_bits_[1] &= ~0x00000800u; +} +inline void LayerParameter::clear_parameter_param() { + if (parameter_param_ != NULL) parameter_param_->::caffe::ParameterParameter::Clear(); + clear_has_parameter_param(); +} +inline const ::caffe::ParameterParameter& LayerParameter::parameter_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.parameter_param) + return parameter_param_ != NULL ? *parameter_param_ + : *::caffe::ParameterParameter::internal_default_instance(); +} +inline ::caffe::ParameterParameter* LayerParameter::mutable_parameter_param() { + set_has_parameter_param(); + if (parameter_param_ == NULL) { + parameter_param_ = new ::caffe::ParameterParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.parameter_param) + return parameter_param_; +} +inline ::caffe::ParameterParameter* LayerParameter::release_parameter_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.parameter_param) + clear_has_parameter_param(); + ::caffe::ParameterParameter* temp = parameter_param_; + parameter_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_parameter_param(::caffe::ParameterParameter* parameter_param) { + delete parameter_param_; + parameter_param_ = parameter_param; + if (parameter_param) { + set_has_parameter_param(); + } else { + clear_has_parameter_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.parameter_param) +} + +// optional .caffe.PoolingParameter pooling_param = 121; +inline bool LayerParameter::has_pooling_param() const { + return (_has_bits_[1] & 0x00001000u) != 0; +} +inline void LayerParameter::set_has_pooling_param() { + _has_bits_[1] |= 0x00001000u; +} +inline void LayerParameter::clear_has_pooling_param() { + _has_bits_[1] &= ~0x00001000u; +} +inline void LayerParameter::clear_pooling_param() { + if (pooling_param_ != NULL) pooling_param_->::caffe::PoolingParameter::Clear(); + clear_has_pooling_param(); +} +inline const ::caffe::PoolingParameter& LayerParameter::pooling_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.pooling_param) + return pooling_param_ != NULL ? *pooling_param_ + : *::caffe::PoolingParameter::internal_default_instance(); +} +inline ::caffe::PoolingParameter* LayerParameter::mutable_pooling_param() { + set_has_pooling_param(); + if (pooling_param_ == NULL) { + pooling_param_ = new ::caffe::PoolingParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.pooling_param) + return pooling_param_; +} +inline ::caffe::PoolingParameter* LayerParameter::release_pooling_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.pooling_param) + clear_has_pooling_param(); + ::caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param) { + delete pooling_param_; + pooling_param_ = pooling_param; + if (pooling_param) { + set_has_pooling_param(); + } else { + clear_has_pooling_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.pooling_param) +} + +// optional .caffe.PowerParameter power_param = 122; +inline bool LayerParameter::has_power_param() const { + return (_has_bits_[1] & 0x00002000u) != 0; +} +inline void LayerParameter::set_has_power_param() { + _has_bits_[1] |= 0x00002000u; +} +inline void LayerParameter::clear_has_power_param() { + _has_bits_[1] &= ~0x00002000u; +} +inline void LayerParameter::clear_power_param() { + if (power_param_ != NULL) power_param_->::caffe::PowerParameter::Clear(); + clear_has_power_param(); +} +inline const ::caffe::PowerParameter& LayerParameter::power_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.power_param) + return power_param_ != NULL ? *power_param_ + : *::caffe::PowerParameter::internal_default_instance(); +} +inline ::caffe::PowerParameter* LayerParameter::mutable_power_param() { + set_has_power_param(); + if (power_param_ == NULL) { + power_param_ = new ::caffe::PowerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.power_param) + return power_param_; +} +inline ::caffe::PowerParameter* LayerParameter::release_power_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.power_param) + clear_has_power_param(); + ::caffe::PowerParameter* temp = power_param_; + power_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_power_param(::caffe::PowerParameter* power_param) { + delete power_param_; + power_param_ = power_param; + if (power_param) { + set_has_power_param(); + } else { + clear_has_power_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.power_param) +} + +// optional .caffe.PReLUParameter prelu_param = 131; +inline bool LayerParameter::has_prelu_param() const { + return (_has_bits_[1] & 0x00004000u) != 0; +} +inline void LayerParameter::set_has_prelu_param() { + _has_bits_[1] |= 0x00004000u; +} +inline void LayerParameter::clear_has_prelu_param() { + _has_bits_[1] &= ~0x00004000u; +} +inline void LayerParameter::clear_prelu_param() { + if (prelu_param_ != NULL) prelu_param_->::caffe::PReLUParameter::Clear(); + clear_has_prelu_param(); +} +inline const ::caffe::PReLUParameter& LayerParameter::prelu_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.prelu_param) + return prelu_param_ != NULL ? *prelu_param_ + : *::caffe::PReLUParameter::internal_default_instance(); +} +inline ::caffe::PReLUParameter* LayerParameter::mutable_prelu_param() { + set_has_prelu_param(); + if (prelu_param_ == NULL) { + prelu_param_ = new ::caffe::PReLUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.prelu_param) + return prelu_param_; +} +inline ::caffe::PReLUParameter* LayerParameter::release_prelu_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.prelu_param) + clear_has_prelu_param(); + ::caffe::PReLUParameter* temp = prelu_param_; + prelu_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_prelu_param(::caffe::PReLUParameter* prelu_param) { + delete prelu_param_; + prelu_param_ = prelu_param; + if (prelu_param) { + set_has_prelu_param(); + } else { + clear_has_prelu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.prelu_param) +} + +// optional .caffe.PriorBoxParameter prior_box_param = 150; +inline bool LayerParameter::has_prior_box_param() const { + return (_has_bits_[1] & 0x00008000u) != 0; +} +inline void LayerParameter::set_has_prior_box_param() { + _has_bits_[1] |= 0x00008000u; +} +inline void LayerParameter::clear_has_prior_box_param() { + _has_bits_[1] &= ~0x00008000u; +} +inline void LayerParameter::clear_prior_box_param() { + if (prior_box_param_ != NULL) prior_box_param_->::caffe::PriorBoxParameter::Clear(); + clear_has_prior_box_param(); +} +inline const ::caffe::PriorBoxParameter& LayerParameter::prior_box_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.prior_box_param) + return prior_box_param_ != NULL ? *prior_box_param_ + : *::caffe::PriorBoxParameter::internal_default_instance(); +} +inline ::caffe::PriorBoxParameter* LayerParameter::mutable_prior_box_param() { + set_has_prior_box_param(); + if (prior_box_param_ == NULL) { + prior_box_param_ = new ::caffe::PriorBoxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.prior_box_param) + return prior_box_param_; +} +inline ::caffe::PriorBoxParameter* LayerParameter::release_prior_box_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.prior_box_param) + clear_has_prior_box_param(); + ::caffe::PriorBoxParameter* temp = prior_box_param_; + prior_box_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_prior_box_param(::caffe::PriorBoxParameter* prior_box_param) { + delete prior_box_param_; + prior_box_param_ = prior_box_param; + if (prior_box_param) { + set_has_prior_box_param(); + } else { + clear_has_prior_box_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.prior_box_param) +} + +// optional .caffe.PythonParameter python_param = 130; +inline bool LayerParameter::has_python_param() const { + return (_has_bits_[1] & 0x00010000u) != 0; +} +inline void LayerParameter::set_has_python_param() { + _has_bits_[1] |= 0x00010000u; +} +inline void LayerParameter::clear_has_python_param() { + _has_bits_[1] &= ~0x00010000u; +} +inline void LayerParameter::clear_python_param() { + if (python_param_ != NULL) python_param_->::caffe::PythonParameter::Clear(); + clear_has_python_param(); +} +inline const ::caffe::PythonParameter& LayerParameter::python_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.python_param) + return python_param_ != NULL ? *python_param_ + : *::caffe::PythonParameter::internal_default_instance(); +} +inline ::caffe::PythonParameter* LayerParameter::mutable_python_param() { + set_has_python_param(); + if (python_param_ == NULL) { + python_param_ = new ::caffe::PythonParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.python_param) + return python_param_; +} +inline ::caffe::PythonParameter* LayerParameter::release_python_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.python_param) + clear_has_python_param(); + ::caffe::PythonParameter* temp = python_param_; + python_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_python_param(::caffe::PythonParameter* python_param) { + delete python_param_; + python_param_ = python_param; + if (python_param) { + set_has_python_param(); + } else { + clear_has_python_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.python_param) +} + +// optional .caffe.RecurrentParameter recurrent_param = 146; +inline bool LayerParameter::has_recurrent_param() const { + return (_has_bits_[1] & 0x00020000u) != 0; +} +inline void LayerParameter::set_has_recurrent_param() { + _has_bits_[1] |= 0x00020000u; +} +inline void LayerParameter::clear_has_recurrent_param() { + _has_bits_[1] &= ~0x00020000u; +} +inline void LayerParameter::clear_recurrent_param() { + if (recurrent_param_ != NULL) recurrent_param_->::caffe::RecurrentParameter::Clear(); + clear_has_recurrent_param(); +} +inline const ::caffe::RecurrentParameter& LayerParameter::recurrent_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.recurrent_param) + return recurrent_param_ != NULL ? *recurrent_param_ + : *::caffe::RecurrentParameter::internal_default_instance(); +} +inline ::caffe::RecurrentParameter* LayerParameter::mutable_recurrent_param() { + set_has_recurrent_param(); + if (recurrent_param_ == NULL) { + recurrent_param_ = new ::caffe::RecurrentParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.recurrent_param) + return recurrent_param_; +} +inline ::caffe::RecurrentParameter* LayerParameter::release_recurrent_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.recurrent_param) + clear_has_recurrent_param(); + ::caffe::RecurrentParameter* temp = recurrent_param_; + recurrent_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_recurrent_param(::caffe::RecurrentParameter* recurrent_param) { + delete recurrent_param_; + recurrent_param_ = recurrent_param; + if (recurrent_param) { + set_has_recurrent_param(); + } else { + clear_has_recurrent_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.recurrent_param) +} + +// optional .caffe.ReductionParameter reduction_param = 136; +inline bool LayerParameter::has_reduction_param() const { + return (_has_bits_[1] & 0x00040000u) != 0; +} +inline void LayerParameter::set_has_reduction_param() { + _has_bits_[1] |= 0x00040000u; +} +inline void LayerParameter::clear_has_reduction_param() { + _has_bits_[1] &= ~0x00040000u; +} +inline void LayerParameter::clear_reduction_param() { + if (reduction_param_ != NULL) reduction_param_->::caffe::ReductionParameter::Clear(); + clear_has_reduction_param(); +} +inline const ::caffe::ReductionParameter& LayerParameter::reduction_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.reduction_param) + return reduction_param_ != NULL ? *reduction_param_ + : *::caffe::ReductionParameter::internal_default_instance(); +} +inline ::caffe::ReductionParameter* LayerParameter::mutable_reduction_param() { + set_has_reduction_param(); + if (reduction_param_ == NULL) { + reduction_param_ = new ::caffe::ReductionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.reduction_param) + return reduction_param_; +} +inline ::caffe::ReductionParameter* LayerParameter::release_reduction_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.reduction_param) + clear_has_reduction_param(); + ::caffe::ReductionParameter* temp = reduction_param_; + reduction_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_reduction_param(::caffe::ReductionParameter* reduction_param) { + delete reduction_param_; + reduction_param_ = reduction_param; + if (reduction_param) { + set_has_reduction_param(); + } else { + clear_has_reduction_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.reduction_param) +} + +// optional .caffe.ReLUParameter relu_param = 123; +inline bool LayerParameter::has_relu_param() const { + return (_has_bits_[1] & 0x00080000u) != 0; +} +inline void LayerParameter::set_has_relu_param() { + _has_bits_[1] |= 0x00080000u; +} +inline void LayerParameter::clear_has_relu_param() { + _has_bits_[1] &= ~0x00080000u; +} +inline void LayerParameter::clear_relu_param() { + if (relu_param_ != NULL) relu_param_->::caffe::ReLUParameter::Clear(); + clear_has_relu_param(); +} +inline const ::caffe::ReLUParameter& LayerParameter::relu_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.relu_param) + return relu_param_ != NULL ? *relu_param_ + : *::caffe::ReLUParameter::internal_default_instance(); +} +inline ::caffe::ReLUParameter* LayerParameter::mutable_relu_param() { + set_has_relu_param(); + if (relu_param_ == NULL) { + relu_param_ = new ::caffe::ReLUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.relu_param) + return relu_param_; +} +inline ::caffe::ReLUParameter* LayerParameter::release_relu_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.relu_param) + clear_has_relu_param(); + ::caffe::ReLUParameter* temp = relu_param_; + relu_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_relu_param(::caffe::ReLUParameter* relu_param) { + delete relu_param_; + relu_param_ = relu_param; + if (relu_param) { + set_has_relu_param(); + } else { + clear_has_relu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.relu_param) +} + +// optional .caffe.ReshapeParameter reshape_param = 133; +inline bool LayerParameter::has_reshape_param() const { + return (_has_bits_[1] & 0x00100000u) != 0; +} +inline void LayerParameter::set_has_reshape_param() { + _has_bits_[1] |= 0x00100000u; +} +inline void LayerParameter::clear_has_reshape_param() { + _has_bits_[1] &= ~0x00100000u; +} +inline void LayerParameter::clear_reshape_param() { + if (reshape_param_ != NULL) reshape_param_->::caffe::ReshapeParameter::Clear(); + clear_has_reshape_param(); +} +inline const ::caffe::ReshapeParameter& LayerParameter::reshape_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.reshape_param) + return reshape_param_ != NULL ? *reshape_param_ + : *::caffe::ReshapeParameter::internal_default_instance(); +} +inline ::caffe::ReshapeParameter* LayerParameter::mutable_reshape_param() { + set_has_reshape_param(); + if (reshape_param_ == NULL) { + reshape_param_ = new ::caffe::ReshapeParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.reshape_param) + return reshape_param_; +} +inline ::caffe::ReshapeParameter* LayerParameter::release_reshape_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.reshape_param) + clear_has_reshape_param(); + ::caffe::ReshapeParameter* temp = reshape_param_; + reshape_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_reshape_param(::caffe::ReshapeParameter* reshape_param) { + delete reshape_param_; + reshape_param_ = reshape_param; + if (reshape_param) { + set_has_reshape_param(); + } else { + clear_has_reshape_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.reshape_param) +} + +// optional .caffe.ScaleParameter scale_param = 142; +inline bool LayerParameter::has_scale_param() const { + return (_has_bits_[1] & 0x00200000u) != 0; +} +inline void LayerParameter::set_has_scale_param() { + _has_bits_[1] |= 0x00200000u; +} +inline void LayerParameter::clear_has_scale_param() { + _has_bits_[1] &= ~0x00200000u; +} +inline void LayerParameter::clear_scale_param() { + if (scale_param_ != NULL) scale_param_->::caffe::ScaleParameter::Clear(); + clear_has_scale_param(); +} +inline const ::caffe::ScaleParameter& LayerParameter::scale_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.scale_param) + return scale_param_ != NULL ? *scale_param_ + : *::caffe::ScaleParameter::internal_default_instance(); +} +inline ::caffe::ScaleParameter* LayerParameter::mutable_scale_param() { + set_has_scale_param(); + if (scale_param_ == NULL) { + scale_param_ = new ::caffe::ScaleParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.scale_param) + return scale_param_; +} +inline ::caffe::ScaleParameter* LayerParameter::release_scale_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.scale_param) + clear_has_scale_param(); + ::caffe::ScaleParameter* temp = scale_param_; + scale_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_scale_param(::caffe::ScaleParameter* scale_param) { + delete scale_param_; + scale_param_ = scale_param; + if (scale_param) { + set_has_scale_param(); + } else { + clear_has_scale_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.scale_param) +} + +// optional .caffe.SigmoidParameter sigmoid_param = 124; +inline bool LayerParameter::has_sigmoid_param() const { + return (_has_bits_[1] & 0x00400000u) != 0; +} +inline void LayerParameter::set_has_sigmoid_param() { + _has_bits_[1] |= 0x00400000u; +} +inline void LayerParameter::clear_has_sigmoid_param() { + _has_bits_[1] &= ~0x00400000u; +} +inline void LayerParameter::clear_sigmoid_param() { + if (sigmoid_param_ != NULL) sigmoid_param_->::caffe::SigmoidParameter::Clear(); + clear_has_sigmoid_param(); +} +inline const ::caffe::SigmoidParameter& LayerParameter::sigmoid_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.sigmoid_param) + return sigmoid_param_ != NULL ? *sigmoid_param_ + : *::caffe::SigmoidParameter::internal_default_instance(); +} +inline ::caffe::SigmoidParameter* LayerParameter::mutable_sigmoid_param() { + set_has_sigmoid_param(); + if (sigmoid_param_ == NULL) { + sigmoid_param_ = new ::caffe::SigmoidParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.sigmoid_param) + return sigmoid_param_; +} +inline ::caffe::SigmoidParameter* LayerParameter::release_sigmoid_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.sigmoid_param) + clear_has_sigmoid_param(); + ::caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param) { + delete sigmoid_param_; + sigmoid_param_ = sigmoid_param; + if (sigmoid_param) { + set_has_sigmoid_param(); + } else { + clear_has_sigmoid_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.sigmoid_param) +} + +// optional .caffe.SoftmaxParameter softmax_param = 125; +inline bool LayerParameter::has_softmax_param() const { + return (_has_bits_[1] & 0x00800000u) != 0; +} +inline void LayerParameter::set_has_softmax_param() { + _has_bits_[1] |= 0x00800000u; +} +inline void LayerParameter::clear_has_softmax_param() { + _has_bits_[1] &= ~0x00800000u; +} +inline void LayerParameter::clear_softmax_param() { + if (softmax_param_ != NULL) softmax_param_->::caffe::SoftmaxParameter::Clear(); + clear_has_softmax_param(); +} +inline const ::caffe::SoftmaxParameter& LayerParameter::softmax_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.softmax_param) + return softmax_param_ != NULL ? *softmax_param_ + : *::caffe::SoftmaxParameter::internal_default_instance(); +} +inline ::caffe::SoftmaxParameter* LayerParameter::mutable_softmax_param() { + set_has_softmax_param(); + if (softmax_param_ == NULL) { + softmax_param_ = new ::caffe::SoftmaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.softmax_param) + return softmax_param_; +} +inline ::caffe::SoftmaxParameter* LayerParameter::release_softmax_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.softmax_param) + clear_has_softmax_param(); + ::caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param) { + delete softmax_param_; + softmax_param_ = softmax_param; + if (softmax_param) { + set_has_softmax_param(); + } else { + clear_has_softmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.softmax_param) +} + +// optional .caffe.SPPParameter spp_param = 132; +inline bool LayerParameter::has_spp_param() const { + return (_has_bits_[1] & 0x01000000u) != 0; +} +inline void LayerParameter::set_has_spp_param() { + _has_bits_[1] |= 0x01000000u; +} +inline void LayerParameter::clear_has_spp_param() { + _has_bits_[1] &= ~0x01000000u; +} +inline void LayerParameter::clear_spp_param() { + if (spp_param_ != NULL) spp_param_->::caffe::SPPParameter::Clear(); + clear_has_spp_param(); +} +inline const ::caffe::SPPParameter& LayerParameter::spp_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.spp_param) + return spp_param_ != NULL ? *spp_param_ + : *::caffe::SPPParameter::internal_default_instance(); +} +inline ::caffe::SPPParameter* LayerParameter::mutable_spp_param() { + set_has_spp_param(); + if (spp_param_ == NULL) { + spp_param_ = new ::caffe::SPPParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.spp_param) + return spp_param_; +} +inline ::caffe::SPPParameter* LayerParameter::release_spp_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.spp_param) + clear_has_spp_param(); + ::caffe::SPPParameter* temp = spp_param_; + spp_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_spp_param(::caffe::SPPParameter* spp_param) { + delete spp_param_; + spp_param_ = spp_param; + if (spp_param) { + set_has_spp_param(); + } else { + clear_has_spp_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.spp_param) +} + +// optional .caffe.SliceParameter slice_param = 126; +inline bool LayerParameter::has_slice_param() const { + return (_has_bits_[1] & 0x02000000u) != 0; +} +inline void LayerParameter::set_has_slice_param() { + _has_bits_[1] |= 0x02000000u; +} +inline void LayerParameter::clear_has_slice_param() { + _has_bits_[1] &= ~0x02000000u; +} +inline void LayerParameter::clear_slice_param() { + if (slice_param_ != NULL) slice_param_->::caffe::SliceParameter::Clear(); + clear_has_slice_param(); +} +inline const ::caffe::SliceParameter& LayerParameter::slice_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.slice_param) + return slice_param_ != NULL ? *slice_param_ + : *::caffe::SliceParameter::internal_default_instance(); +} +inline ::caffe::SliceParameter* LayerParameter::mutable_slice_param() { + set_has_slice_param(); + if (slice_param_ == NULL) { + slice_param_ = new ::caffe::SliceParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.slice_param) + return slice_param_; +} +inline ::caffe::SliceParameter* LayerParameter::release_slice_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.slice_param) + clear_has_slice_param(); + ::caffe::SliceParameter* temp = slice_param_; + slice_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_slice_param(::caffe::SliceParameter* slice_param) { + delete slice_param_; + slice_param_ = slice_param; + if (slice_param) { + set_has_slice_param(); + } else { + clear_has_slice_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.slice_param) +} + +// optional .caffe.TanHParameter tanh_param = 127; +inline bool LayerParameter::has_tanh_param() const { + return (_has_bits_[1] & 0x04000000u) != 0; +} +inline void LayerParameter::set_has_tanh_param() { + _has_bits_[1] |= 0x04000000u; +} +inline void LayerParameter::clear_has_tanh_param() { + _has_bits_[1] &= ~0x04000000u; +} +inline void LayerParameter::clear_tanh_param() { + if (tanh_param_ != NULL) tanh_param_->::caffe::TanHParameter::Clear(); + clear_has_tanh_param(); +} +inline const ::caffe::TanHParameter& LayerParameter::tanh_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.tanh_param) + return tanh_param_ != NULL ? *tanh_param_ + : *::caffe::TanHParameter::internal_default_instance(); +} +inline ::caffe::TanHParameter* LayerParameter::mutable_tanh_param() { + set_has_tanh_param(); + if (tanh_param_ == NULL) { + tanh_param_ = new ::caffe::TanHParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.tanh_param) + return tanh_param_; +} +inline ::caffe::TanHParameter* LayerParameter::release_tanh_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.tanh_param) + clear_has_tanh_param(); + ::caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_tanh_param(::caffe::TanHParameter* tanh_param) { + delete tanh_param_; + tanh_param_ = tanh_param; + if (tanh_param) { + set_has_tanh_param(); + } else { + clear_has_tanh_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.tanh_param) +} + +// optional .caffe.ThresholdParameter threshold_param = 128; +inline bool LayerParameter::has_threshold_param() const { + return (_has_bits_[1] & 0x08000000u) != 0; +} +inline void LayerParameter::set_has_threshold_param() { + _has_bits_[1] |= 0x08000000u; +} +inline void LayerParameter::clear_has_threshold_param() { + _has_bits_[1] &= ~0x08000000u; +} +inline void LayerParameter::clear_threshold_param() { + if (threshold_param_ != NULL) threshold_param_->::caffe::ThresholdParameter::Clear(); + clear_has_threshold_param(); +} +inline const ::caffe::ThresholdParameter& LayerParameter::threshold_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.threshold_param) + return threshold_param_ != NULL ? *threshold_param_ + : *::caffe::ThresholdParameter::internal_default_instance(); +} +inline ::caffe::ThresholdParameter* LayerParameter::mutable_threshold_param() { + set_has_threshold_param(); + if (threshold_param_ == NULL) { + threshold_param_ = new ::caffe::ThresholdParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.threshold_param) + return threshold_param_; +} +inline ::caffe::ThresholdParameter* LayerParameter::release_threshold_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.threshold_param) + clear_has_threshold_param(); + ::caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param) { + delete threshold_param_; + threshold_param_ = threshold_param; + if (threshold_param) { + set_has_threshold_param(); + } else { + clear_has_threshold_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.threshold_param) +} + +// optional .caffe.TileParameter tile_param = 138; +inline bool LayerParameter::has_tile_param() const { + return (_has_bits_[1] & 0x10000000u) != 0; +} +inline void LayerParameter::set_has_tile_param() { + _has_bits_[1] |= 0x10000000u; +} +inline void LayerParameter::clear_has_tile_param() { + _has_bits_[1] &= ~0x10000000u; +} +inline void LayerParameter::clear_tile_param() { + if (tile_param_ != NULL) tile_param_->::caffe::TileParameter::Clear(); + clear_has_tile_param(); +} +inline const ::caffe::TileParameter& LayerParameter::tile_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.tile_param) + return tile_param_ != NULL ? *tile_param_ + : *::caffe::TileParameter::internal_default_instance(); +} +inline ::caffe::TileParameter* LayerParameter::mutable_tile_param() { + set_has_tile_param(); + if (tile_param_ == NULL) { + tile_param_ = new ::caffe::TileParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.tile_param) + return tile_param_; +} +inline ::caffe::TileParameter* LayerParameter::release_tile_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.tile_param) + clear_has_tile_param(); + ::caffe::TileParameter* temp = tile_param_; + tile_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_tile_param(::caffe::TileParameter* tile_param) { + delete tile_param_; + tile_param_ = tile_param; + if (tile_param) { + set_has_tile_param(); + } else { + clear_has_tile_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.tile_param) +} + +// optional .caffe.WindowDataParameter window_data_param = 129; +inline bool LayerParameter::has_window_data_param() const { + return (_has_bits_[1] & 0x20000000u) != 0; +} +inline void LayerParameter::set_has_window_data_param() { + _has_bits_[1] |= 0x20000000u; +} +inline void LayerParameter::clear_has_window_data_param() { + _has_bits_[1] &= ~0x20000000u; +} +inline void LayerParameter::clear_window_data_param() { + if (window_data_param_ != NULL) window_data_param_->::caffe::WindowDataParameter::Clear(); + clear_has_window_data_param(); +} +inline const ::caffe::WindowDataParameter& LayerParameter::window_data_param() const { + // @@protoc_insertion_point(field_get:caffe.LayerParameter.window_data_param) + return window_data_param_ != NULL ? *window_data_param_ + : *::caffe::WindowDataParameter::internal_default_instance(); +} +inline ::caffe::WindowDataParameter* LayerParameter::mutable_window_data_param() { + set_has_window_data_param(); + if (window_data_param_ == NULL) { + window_data_param_ = new ::caffe::WindowDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.LayerParameter.window_data_param) + return window_data_param_; +} +inline ::caffe::WindowDataParameter* LayerParameter::release_window_data_param() { + // @@protoc_insertion_point(field_release:caffe.LayerParameter.window_data_param) + clear_has_window_data_param(); + ::caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = NULL; + return temp; +} +inline void LayerParameter::set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param) { + delete window_data_param_; + window_data_param_ = window_data_param; + if (window_data_param) { + set_has_window_data_param(); + } else { + clear_has_window_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.LayerParameter.window_data_param) +} + +inline const LayerParameter* LayerParameter::internal_default_instance() { + return &LayerParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// TransformationParameter + +// optional float scale = 1 [default = 1]; +inline bool TransformationParameter::has_scale() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void TransformationParameter::set_has_scale() { + _has_bits_[0] |= 0x00000001u; +} +inline void TransformationParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000001u; +} +inline void TransformationParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float TransformationParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.scale) + return scale_; +} +inline void TransformationParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.scale) +} + +// optional bool mirror = 2 [default = false]; +inline bool TransformationParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void TransformationParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000002u; +} +inline void TransformationParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000002u; +} +inline void TransformationParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +inline bool TransformationParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.mirror) + return mirror_; +} +inline void TransformationParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.mirror) +} + +// optional uint32 crop_size = 3 [default = 0]; +inline bool TransformationParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void TransformationParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000004u; +} +inline void TransformationParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000004u; +} +inline void TransformationParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +inline ::google::protobuf::uint32 TransformationParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.crop_size) + return crop_size_; +} +inline void TransformationParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.crop_size) +} + +// optional string mean_file = 4; +inline bool TransformationParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void TransformationParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000008u; +} +inline void TransformationParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000008u; +} +inline void TransformationParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +inline const ::std::string& TransformationParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void TransformationParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.mean_file) +} +inline void TransformationParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.TransformationParameter.mean_file) +} +inline void TransformationParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.TransformationParameter.mean_file) +} +inline ::std::string* TransformationParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.TransformationParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* TransformationParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.TransformationParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void TransformationParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.TransformationParameter.mean_file) +} + +// repeated float mean_value = 5; +inline int TransformationParameter::mean_value_size() const { + return mean_value_.size(); +} +inline void TransformationParameter::clear_mean_value() { + mean_value_.Clear(); +} +inline float TransformationParameter::mean_value(int index) const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.mean_value) + return mean_value_.Get(index); +} +inline void TransformationParameter::set_mean_value(int index, float value) { + mean_value_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.mean_value) +} +inline void TransformationParameter::add_mean_value(float value) { + mean_value_.Add(value); + // @@protoc_insertion_point(field_add:caffe.TransformationParameter.mean_value) +} +inline const ::google::protobuf::RepeatedField< float >& +TransformationParameter::mean_value() const { + // @@protoc_insertion_point(field_list:caffe.TransformationParameter.mean_value) + return mean_value_; +} +inline ::google::protobuf::RepeatedField< float >* +TransformationParameter::mutable_mean_value() { + // @@protoc_insertion_point(field_mutable_list:caffe.TransformationParameter.mean_value) + return &mean_value_; +} + +// optional bool force_color = 6 [default = false]; +inline bool TransformationParameter::has_force_color() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void TransformationParameter::set_has_force_color() { + _has_bits_[0] |= 0x00000020u; +} +inline void TransformationParameter::clear_has_force_color() { + _has_bits_[0] &= ~0x00000020u; +} +inline void TransformationParameter::clear_force_color() { + force_color_ = false; + clear_has_force_color(); +} +inline bool TransformationParameter::force_color() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.force_color) + return force_color_; +} +inline void TransformationParameter::set_force_color(bool value) { + set_has_force_color(); + force_color_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.force_color) +} + +// optional bool force_gray = 7 [default = false]; +inline bool TransformationParameter::has_force_gray() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void TransformationParameter::set_has_force_gray() { + _has_bits_[0] |= 0x00000040u; +} +inline void TransformationParameter::clear_has_force_gray() { + _has_bits_[0] &= ~0x00000040u; +} +inline void TransformationParameter::clear_force_gray() { + force_gray_ = false; + clear_has_force_gray(); +} +inline bool TransformationParameter::force_gray() const { + // @@protoc_insertion_point(field_get:caffe.TransformationParameter.force_gray) + return force_gray_; +} +inline void TransformationParameter::set_force_gray(bool value) { + set_has_force_gray(); + force_gray_ = value; + // @@protoc_insertion_point(field_set:caffe.TransformationParameter.force_gray) +} + +inline const TransformationParameter* TransformationParameter::internal_default_instance() { + return &TransformationParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// LossParameter + +// optional int32 ignore_label = 1; +inline bool LossParameter::has_ignore_label() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LossParameter::set_has_ignore_label() { + _has_bits_[0] |= 0x00000001u; +} +inline void LossParameter::clear_has_ignore_label() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LossParameter::clear_ignore_label() { + ignore_label_ = 0; + clear_has_ignore_label(); +} +inline ::google::protobuf::int32 LossParameter::ignore_label() const { + // @@protoc_insertion_point(field_get:caffe.LossParameter.ignore_label) + return ignore_label_; +} +inline void LossParameter::set_ignore_label(::google::protobuf::int32 value) { + set_has_ignore_label(); + ignore_label_ = value; + // @@protoc_insertion_point(field_set:caffe.LossParameter.ignore_label) +} + +// optional .caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID]; +inline bool LossParameter::has_normalization() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LossParameter::set_has_normalization() { + _has_bits_[0] |= 0x00000002u; +} +inline void LossParameter::clear_has_normalization() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LossParameter::clear_normalization() { + normalization_ = 1; + clear_has_normalization(); +} +inline ::caffe::LossParameter_NormalizationMode LossParameter::normalization() const { + // @@protoc_insertion_point(field_get:caffe.LossParameter.normalization) + return static_cast< ::caffe::LossParameter_NormalizationMode >(normalization_); +} +inline void LossParameter::set_normalization(::caffe::LossParameter_NormalizationMode value) { + assert(::caffe::LossParameter_NormalizationMode_IsValid(value)); + set_has_normalization(); + normalization_ = value; + // @@protoc_insertion_point(field_set:caffe.LossParameter.normalization) +} + +// optional bool normalize = 2; +inline bool LossParameter::has_normalize() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LossParameter::set_has_normalize() { + _has_bits_[0] |= 0x00000004u; +} +inline void LossParameter::clear_has_normalize() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LossParameter::clear_normalize() { + normalize_ = false; + clear_has_normalize(); +} +inline bool LossParameter::normalize() const { + // @@protoc_insertion_point(field_get:caffe.LossParameter.normalize) + return normalize_; +} +inline void LossParameter::set_normalize(bool value) { + set_has_normalize(); + normalize_ = value; + // @@protoc_insertion_point(field_set:caffe.LossParameter.normalize) +} + +inline const LossParameter* LossParameter::internal_default_instance() { + return &LossParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// AccuracyParameter + +// optional uint32 top_k = 1 [default = 1]; +inline bool AccuracyParameter::has_top_k() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccuracyParameter::set_has_top_k() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccuracyParameter::clear_has_top_k() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccuracyParameter::clear_top_k() { + top_k_ = 1u; + clear_has_top_k(); +} +inline ::google::protobuf::uint32 AccuracyParameter::top_k() const { + // @@protoc_insertion_point(field_get:caffe.AccuracyParameter.top_k) + return top_k_; +} +inline void AccuracyParameter::set_top_k(::google::protobuf::uint32 value) { + set_has_top_k(); + top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.AccuracyParameter.top_k) +} + +// optional int32 axis = 2 [default = 1]; +inline bool AccuracyParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccuracyParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccuracyParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccuracyParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 AccuracyParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.AccuracyParameter.axis) + return axis_; +} +inline void AccuracyParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.AccuracyParameter.axis) +} + +// optional int32 ignore_label = 3; +inline bool AccuracyParameter::has_ignore_label() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccuracyParameter::set_has_ignore_label() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccuracyParameter::clear_has_ignore_label() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccuracyParameter::clear_ignore_label() { + ignore_label_ = 0; + clear_has_ignore_label(); +} +inline ::google::protobuf::int32 AccuracyParameter::ignore_label() const { + // @@protoc_insertion_point(field_get:caffe.AccuracyParameter.ignore_label) + return ignore_label_; +} +inline void AccuracyParameter::set_ignore_label(::google::protobuf::int32 value) { + set_has_ignore_label(); + ignore_label_ = value; + // @@protoc_insertion_point(field_set:caffe.AccuracyParameter.ignore_label) +} + +inline const AccuracyParameter* AccuracyParameter::internal_default_instance() { + return &AccuracyParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ArgMaxParameter + +// optional bool out_max_val = 1 [default = false]; +inline bool ArgMaxParameter::has_out_max_val() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ArgMaxParameter::set_has_out_max_val() { + _has_bits_[0] |= 0x00000001u; +} +inline void ArgMaxParameter::clear_has_out_max_val() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ArgMaxParameter::clear_out_max_val() { + out_max_val_ = false; + clear_has_out_max_val(); +} +inline bool ArgMaxParameter::out_max_val() const { + // @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.out_max_val) + return out_max_val_; +} +inline void ArgMaxParameter::set_out_max_val(bool value) { + set_has_out_max_val(); + out_max_val_ = value; + // @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.out_max_val) +} + +// optional uint32 top_k = 2 [default = 1]; +inline bool ArgMaxParameter::has_top_k() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ArgMaxParameter::set_has_top_k() { + _has_bits_[0] |= 0x00000002u; +} +inline void ArgMaxParameter::clear_has_top_k() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ArgMaxParameter::clear_top_k() { + top_k_ = 1u; + clear_has_top_k(); +} +inline ::google::protobuf::uint32 ArgMaxParameter::top_k() const { + // @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.top_k) + return top_k_; +} +inline void ArgMaxParameter::set_top_k(::google::protobuf::uint32 value) { + set_has_top_k(); + top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.top_k) +} + +// optional int32 axis = 3; +inline bool ArgMaxParameter::has_axis() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ArgMaxParameter::set_has_axis() { + _has_bits_[0] |= 0x00000004u; +} +inline void ArgMaxParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ArgMaxParameter::clear_axis() { + axis_ = 0; + clear_has_axis(); +} +inline ::google::protobuf::int32 ArgMaxParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ArgMaxParameter.axis) + return axis_; +} +inline void ArgMaxParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ArgMaxParameter.axis) +} + +inline const ArgMaxParameter* ArgMaxParameter::internal_default_instance() { + return &ArgMaxParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ConcatParameter + +// optional int32 axis = 2 [default = 1]; +inline bool ConcatParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ConcatParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +inline void ConcatParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ConcatParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 ConcatParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ConcatParameter.axis) + return axis_; +} +inline void ConcatParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ConcatParameter.axis) +} + +// optional uint32 concat_dim = 1 [default = 1]; +inline bool ConcatParameter::has_concat_dim() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ConcatParameter::set_has_concat_dim() { + _has_bits_[0] |= 0x00000002u; +} +inline void ConcatParameter::clear_has_concat_dim() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ConcatParameter::clear_concat_dim() { + concat_dim_ = 1u; + clear_has_concat_dim(); +} +inline ::google::protobuf::uint32 ConcatParameter::concat_dim() const { + // @@protoc_insertion_point(field_get:caffe.ConcatParameter.concat_dim) + return concat_dim_; +} +inline void ConcatParameter::set_concat_dim(::google::protobuf::uint32 value) { + set_has_concat_dim(); + concat_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.ConcatParameter.concat_dim) +} + +inline const ConcatParameter* ConcatParameter::internal_default_instance() { + return &ConcatParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// BatchNormParameter + +// optional bool use_global_stats = 1; +inline bool BatchNormParameter::has_use_global_stats() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BatchNormParameter::set_has_use_global_stats() { + _has_bits_[0] |= 0x00000001u; +} +inline void BatchNormParameter::clear_has_use_global_stats() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BatchNormParameter::clear_use_global_stats() { + use_global_stats_ = false; + clear_has_use_global_stats(); +} +inline bool BatchNormParameter::use_global_stats() const { + // @@protoc_insertion_point(field_get:caffe.BatchNormParameter.use_global_stats) + return use_global_stats_; +} +inline void BatchNormParameter::set_use_global_stats(bool value) { + set_has_use_global_stats(); + use_global_stats_ = value; + // @@protoc_insertion_point(field_set:caffe.BatchNormParameter.use_global_stats) +} + +// optional float moving_average_fraction = 2 [default = 0.999]; +inline bool BatchNormParameter::has_moving_average_fraction() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BatchNormParameter::set_has_moving_average_fraction() { + _has_bits_[0] |= 0x00000002u; +} +inline void BatchNormParameter::clear_has_moving_average_fraction() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BatchNormParameter::clear_moving_average_fraction() { + moving_average_fraction_ = 0.999f; + clear_has_moving_average_fraction(); +} +inline float BatchNormParameter::moving_average_fraction() const { + // @@protoc_insertion_point(field_get:caffe.BatchNormParameter.moving_average_fraction) + return moving_average_fraction_; +} +inline void BatchNormParameter::set_moving_average_fraction(float value) { + set_has_moving_average_fraction(); + moving_average_fraction_ = value; + // @@protoc_insertion_point(field_set:caffe.BatchNormParameter.moving_average_fraction) +} + +// optional float eps = 3 [default = 1e-05]; +inline bool BatchNormParameter::has_eps() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void BatchNormParameter::set_has_eps() { + _has_bits_[0] |= 0x00000004u; +} +inline void BatchNormParameter::clear_has_eps() { + _has_bits_[0] &= ~0x00000004u; +} +inline void BatchNormParameter::clear_eps() { + eps_ = 1e-05f; + clear_has_eps(); +} +inline float BatchNormParameter::eps() const { + // @@protoc_insertion_point(field_get:caffe.BatchNormParameter.eps) + return eps_; +} +inline void BatchNormParameter::set_eps(float value) { + set_has_eps(); + eps_ = value; + // @@protoc_insertion_point(field_set:caffe.BatchNormParameter.eps) +} + +inline const BatchNormParameter* BatchNormParameter::internal_default_instance() { + return &BatchNormParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// BiasParameter + +// optional int32 axis = 1 [default = 1]; +inline bool BiasParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BiasParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +inline void BiasParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BiasParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 BiasParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.BiasParameter.axis) + return axis_; +} +inline void BiasParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.BiasParameter.axis) +} + +// optional int32 num_axes = 2 [default = 1]; +inline bool BiasParameter::has_num_axes() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BiasParameter::set_has_num_axes() { + _has_bits_[0] |= 0x00000002u; +} +inline void BiasParameter::clear_has_num_axes() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BiasParameter::clear_num_axes() { + num_axes_ = 1; + clear_has_num_axes(); +} +inline ::google::protobuf::int32 BiasParameter::num_axes() const { + // @@protoc_insertion_point(field_get:caffe.BiasParameter.num_axes) + return num_axes_; +} +inline void BiasParameter::set_num_axes(::google::protobuf::int32 value) { + set_has_num_axes(); + num_axes_ = value; + // @@protoc_insertion_point(field_set:caffe.BiasParameter.num_axes) +} + +// optional .caffe.FillerParameter filler = 3; +inline bool BiasParameter::has_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void BiasParameter::set_has_filler() { + _has_bits_[0] |= 0x00000004u; +} +inline void BiasParameter::clear_has_filler() { + _has_bits_[0] &= ~0x00000004u; +} +inline void BiasParameter::clear_filler() { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + clear_has_filler(); +} +inline const ::caffe::FillerParameter& BiasParameter::filler() const { + // @@protoc_insertion_point(field_get:caffe.BiasParameter.filler) + return filler_ != NULL ? *filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* BiasParameter::mutable_filler() { + set_has_filler(); + if (filler_ == NULL) { + filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.BiasParameter.filler) + return filler_; +} +inline ::caffe::FillerParameter* BiasParameter::release_filler() { + // @@protoc_insertion_point(field_release:caffe.BiasParameter.filler) + clear_has_filler(); + ::caffe::FillerParameter* temp = filler_; + filler_ = NULL; + return temp; +} +inline void BiasParameter::set_allocated_filler(::caffe::FillerParameter* filler) { + delete filler_; + filler_ = filler; + if (filler) { + set_has_filler(); + } else { + clear_has_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.BiasParameter.filler) +} + +inline const BiasParameter* BiasParameter::internal_default_instance() { + return &BiasParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ContrastiveLossParameter + +// optional float margin = 1 [default = 1]; +inline bool ContrastiveLossParameter::has_margin() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ContrastiveLossParameter::set_has_margin() { + _has_bits_[0] |= 0x00000001u; +} +inline void ContrastiveLossParameter::clear_has_margin() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ContrastiveLossParameter::clear_margin() { + margin_ = 1; + clear_has_margin(); +} +inline float ContrastiveLossParameter::margin() const { + // @@protoc_insertion_point(field_get:caffe.ContrastiveLossParameter.margin) + return margin_; +} +inline void ContrastiveLossParameter::set_margin(float value) { + set_has_margin(); + margin_ = value; + // @@protoc_insertion_point(field_set:caffe.ContrastiveLossParameter.margin) +} + +// optional bool legacy_version = 2 [default = false]; +inline bool ContrastiveLossParameter::has_legacy_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ContrastiveLossParameter::set_has_legacy_version() { + _has_bits_[0] |= 0x00000002u; +} +inline void ContrastiveLossParameter::clear_has_legacy_version() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ContrastiveLossParameter::clear_legacy_version() { + legacy_version_ = false; + clear_has_legacy_version(); +} +inline bool ContrastiveLossParameter::legacy_version() const { + // @@protoc_insertion_point(field_get:caffe.ContrastiveLossParameter.legacy_version) + return legacy_version_; +} +inline void ContrastiveLossParameter::set_legacy_version(bool value) { + set_has_legacy_version(); + legacy_version_ = value; + // @@protoc_insertion_point(field_set:caffe.ContrastiveLossParameter.legacy_version) +} + +inline const ContrastiveLossParameter* ContrastiveLossParameter::internal_default_instance() { + return &ContrastiveLossParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ConvolutionParameter + +// optional uint32 num_output = 1; +inline bool ConvolutionParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ConvolutionParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +inline void ConvolutionParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ConvolutionParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.num_output) + return num_output_; +} +inline void ConvolutionParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.num_output) +} + +// optional bool bias_term = 2 [default = true]; +inline bool ConvolutionParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ConvolutionParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000002u; +} +inline void ConvolutionParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ConvolutionParameter::clear_bias_term() { + bias_term_ = true; + clear_has_bias_term(); +} +inline bool ConvolutionParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.bias_term) + return bias_term_; +} +inline void ConvolutionParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.bias_term) +} + +// repeated uint32 pad = 3; +inline int ConvolutionParameter::pad_size() const { + return pad_.size(); +} +inline void ConvolutionParameter::clear_pad() { + pad_.Clear(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::pad(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad) + return pad_.Get(index); +} +inline void ConvolutionParameter::set_pad(int index, ::google::protobuf::uint32 value) { + pad_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad) +} +inline void ConvolutionParameter::add_pad(::google::protobuf::uint32 value) { + pad_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.pad) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::pad() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.pad) + return pad_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_pad() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.pad) + return &pad_; +} + +// repeated uint32 kernel_size = 4; +inline int ConvolutionParameter::kernel_size_size() const { + return kernel_size_.size(); +} +inline void ConvolutionParameter::clear_kernel_size() { + kernel_size_.Clear(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::kernel_size(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_size) + return kernel_size_.Get(index); +} +inline void ConvolutionParameter::set_kernel_size(int index, ::google::protobuf::uint32 value) { + kernel_size_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_size) +} +inline void ConvolutionParameter::add_kernel_size(::google::protobuf::uint32 value) { + kernel_size_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.kernel_size) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::kernel_size() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.kernel_size) + return kernel_size_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_kernel_size() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.kernel_size) + return &kernel_size_; +} + +// repeated uint32 stride = 6; +inline int ConvolutionParameter::stride_size() const { + return stride_.size(); +} +inline void ConvolutionParameter::clear_stride() { + stride_.Clear(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::stride(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride) + return stride_.Get(index); +} +inline void ConvolutionParameter::set_stride(int index, ::google::protobuf::uint32 value) { + stride_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride) +} +inline void ConvolutionParameter::add_stride(::google::protobuf::uint32 value) { + stride_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.stride) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::stride() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.stride) + return stride_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_stride() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.stride) + return &stride_; +} + +// repeated uint32 dilation = 18; +inline int ConvolutionParameter::dilation_size() const { + return dilation_.size(); +} +inline void ConvolutionParameter::clear_dilation() { + dilation_.Clear(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::dilation(int index) const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.dilation) + return dilation_.Get(index); +} +inline void ConvolutionParameter::set_dilation(int index, ::google::protobuf::uint32 value) { + dilation_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.dilation) +} +inline void ConvolutionParameter::add_dilation(::google::protobuf::uint32 value) { + dilation_.Add(value); + // @@protoc_insertion_point(field_add:caffe.ConvolutionParameter.dilation) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ConvolutionParameter::dilation() const { + // @@protoc_insertion_point(field_list:caffe.ConvolutionParameter.dilation) + return dilation_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ConvolutionParameter::mutable_dilation() { + // @@protoc_insertion_point(field_mutable_list:caffe.ConvolutionParameter.dilation) + return &dilation_; +} + +// optional uint32 pad_h = 9 [default = 0]; +inline bool ConvolutionParameter::has_pad_h() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void ConvolutionParameter::set_has_pad_h() { + _has_bits_[0] |= 0x00000040u; +} +inline void ConvolutionParameter::clear_has_pad_h() { + _has_bits_[0] &= ~0x00000040u; +} +inline void ConvolutionParameter::clear_pad_h() { + pad_h_ = 0u; + clear_has_pad_h(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::pad_h() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad_h) + return pad_h_; +} +inline void ConvolutionParameter::set_pad_h(::google::protobuf::uint32 value) { + set_has_pad_h(); + pad_h_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad_h) +} + +// optional uint32 pad_w = 10 [default = 0]; +inline bool ConvolutionParameter::has_pad_w() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void ConvolutionParameter::set_has_pad_w() { + _has_bits_[0] |= 0x00000080u; +} +inline void ConvolutionParameter::clear_has_pad_w() { + _has_bits_[0] &= ~0x00000080u; +} +inline void ConvolutionParameter::clear_pad_w() { + pad_w_ = 0u; + clear_has_pad_w(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::pad_w() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.pad_w) + return pad_w_; +} +inline void ConvolutionParameter::set_pad_w(::google::protobuf::uint32 value) { + set_has_pad_w(); + pad_w_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.pad_w) +} + +// optional uint32 kernel_h = 11; +inline bool ConvolutionParameter::has_kernel_h() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void ConvolutionParameter::set_has_kernel_h() { + _has_bits_[0] |= 0x00000100u; +} +inline void ConvolutionParameter::clear_has_kernel_h() { + _has_bits_[0] &= ~0x00000100u; +} +inline void ConvolutionParameter::clear_kernel_h() { + kernel_h_ = 0u; + clear_has_kernel_h(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::kernel_h() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_h) + return kernel_h_; +} +inline void ConvolutionParameter::set_kernel_h(::google::protobuf::uint32 value) { + set_has_kernel_h(); + kernel_h_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_h) +} + +// optional uint32 kernel_w = 12; +inline bool ConvolutionParameter::has_kernel_w() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void ConvolutionParameter::set_has_kernel_w() { + _has_bits_[0] |= 0x00000200u; +} +inline void ConvolutionParameter::clear_has_kernel_w() { + _has_bits_[0] &= ~0x00000200u; +} +inline void ConvolutionParameter::clear_kernel_w() { + kernel_w_ = 0u; + clear_has_kernel_w(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::kernel_w() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.kernel_w) + return kernel_w_; +} +inline void ConvolutionParameter::set_kernel_w(::google::protobuf::uint32 value) { + set_has_kernel_w(); + kernel_w_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.kernel_w) +} + +// optional uint32 stride_h = 13; +inline bool ConvolutionParameter::has_stride_h() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void ConvolutionParameter::set_has_stride_h() { + _has_bits_[0] |= 0x00000400u; +} +inline void ConvolutionParameter::clear_has_stride_h() { + _has_bits_[0] &= ~0x00000400u; +} +inline void ConvolutionParameter::clear_stride_h() { + stride_h_ = 0u; + clear_has_stride_h(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::stride_h() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride_h) + return stride_h_; +} +inline void ConvolutionParameter::set_stride_h(::google::protobuf::uint32 value) { + set_has_stride_h(); + stride_h_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride_h) +} + +// optional uint32 stride_w = 14; +inline bool ConvolutionParameter::has_stride_w() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void ConvolutionParameter::set_has_stride_w() { + _has_bits_[0] |= 0x00000800u; +} +inline void ConvolutionParameter::clear_has_stride_w() { + _has_bits_[0] &= ~0x00000800u; +} +inline void ConvolutionParameter::clear_stride_w() { + stride_w_ = 0u; + clear_has_stride_w(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::stride_w() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.stride_w) + return stride_w_; +} +inline void ConvolutionParameter::set_stride_w(::google::protobuf::uint32 value) { + set_has_stride_w(); + stride_w_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.stride_w) +} + +// optional uint32 group = 5 [default = 1]; +inline bool ConvolutionParameter::has_group() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void ConvolutionParameter::set_has_group() { + _has_bits_[0] |= 0x00001000u; +} +inline void ConvolutionParameter::clear_has_group() { + _has_bits_[0] &= ~0x00001000u; +} +inline void ConvolutionParameter::clear_group() { + group_ = 1u; + clear_has_group(); +} +inline ::google::protobuf::uint32 ConvolutionParameter::group() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.group) + return group_; +} +inline void ConvolutionParameter::set_group(::google::protobuf::uint32 value) { + set_has_group(); + group_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.group) +} + +// optional .caffe.FillerParameter weight_filler = 7; +inline bool ConvolutionParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void ConvolutionParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00002000u; +} +inline void ConvolutionParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00002000u; +} +inline void ConvolutionParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +inline const ::caffe::FillerParameter& ConvolutionParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* ConvolutionParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ConvolutionParameter.weight_filler) + return weight_filler_; +} +inline ::caffe::FillerParameter* ConvolutionParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.ConvolutionParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +inline void ConvolutionParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ConvolutionParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 8; +inline bool ConvolutionParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void ConvolutionParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00004000u; +} +inline void ConvolutionParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00004000u; +} +inline void ConvolutionParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +inline const ::caffe::FillerParameter& ConvolutionParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* ConvolutionParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ConvolutionParameter.bias_filler) + return bias_filler_; +} +inline ::caffe::FillerParameter* ConvolutionParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.ConvolutionParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +inline void ConvolutionParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ConvolutionParameter.bias_filler) +} + +// optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT]; +inline bool ConvolutionParameter::has_engine() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void ConvolutionParameter::set_has_engine() { + _has_bits_[0] |= 0x00008000u; +} +inline void ConvolutionParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00008000u; +} +inline void ConvolutionParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::ConvolutionParameter_Engine ConvolutionParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.engine) + return static_cast< ::caffe::ConvolutionParameter_Engine >(engine_); +} +inline void ConvolutionParameter::set_engine(::caffe::ConvolutionParameter_Engine value) { + assert(::caffe::ConvolutionParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.engine) +} + +// optional int32 axis = 16 [default = 1]; +inline bool ConvolutionParameter::has_axis() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +inline void ConvolutionParameter::set_has_axis() { + _has_bits_[0] |= 0x00010000u; +} +inline void ConvolutionParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00010000u; +} +inline void ConvolutionParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 ConvolutionParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.axis) + return axis_; +} +inline void ConvolutionParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.axis) +} + +// optional bool force_nd_im2col = 17 [default = false]; +inline bool ConvolutionParameter::has_force_nd_im2col() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +inline void ConvolutionParameter::set_has_force_nd_im2col() { + _has_bits_[0] |= 0x00020000u; +} +inline void ConvolutionParameter::clear_has_force_nd_im2col() { + _has_bits_[0] &= ~0x00020000u; +} +inline void ConvolutionParameter::clear_force_nd_im2col() { + force_nd_im2col_ = false; + clear_has_force_nd_im2col(); +} +inline bool ConvolutionParameter::force_nd_im2col() const { + // @@protoc_insertion_point(field_get:caffe.ConvolutionParameter.force_nd_im2col) + return force_nd_im2col_; +} +inline void ConvolutionParameter::set_force_nd_im2col(bool value) { + set_has_force_nd_im2col(); + force_nd_im2col_ = value; + // @@protoc_insertion_point(field_set:caffe.ConvolutionParameter.force_nd_im2col) +} + +inline const ConvolutionParameter* ConvolutionParameter::internal_default_instance() { + return &ConvolutionParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// CropParameter + +// optional int32 axis = 1 [default = 2]; +inline bool CropParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CropParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +inline void CropParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CropParameter::clear_axis() { + axis_ = 2; + clear_has_axis(); +} +inline ::google::protobuf::int32 CropParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.CropParameter.axis) + return axis_; +} +inline void CropParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.CropParameter.axis) +} + +// repeated uint32 offset = 2; +inline int CropParameter::offset_size() const { + return offset_.size(); +} +inline void CropParameter::clear_offset() { + offset_.Clear(); +} +inline ::google::protobuf::uint32 CropParameter::offset(int index) const { + // @@protoc_insertion_point(field_get:caffe.CropParameter.offset) + return offset_.Get(index); +} +inline void CropParameter::set_offset(int index, ::google::protobuf::uint32 value) { + offset_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.CropParameter.offset) +} +inline void CropParameter::add_offset(::google::protobuf::uint32 value) { + offset_.Add(value); + // @@protoc_insertion_point(field_add:caffe.CropParameter.offset) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +CropParameter::offset() const { + // @@protoc_insertion_point(field_list:caffe.CropParameter.offset) + return offset_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +CropParameter::mutable_offset() { + // @@protoc_insertion_point(field_mutable_list:caffe.CropParameter.offset) + return &offset_; +} + +inline const CropParameter* CropParameter::internal_default_instance() { + return &CropParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// DataParameter + +// optional string source = 1; +inline bool DataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +inline void DataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +inline const ::std::string& DataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void DataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.DataParameter.source) +} +inline void DataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.DataParameter.source) +} +inline void DataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.DataParameter.source) +} +inline ::std::string* DataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.DataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* DataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.DataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void DataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.DataParameter.source) +} + +// optional uint32 batch_size = 4; +inline bool DataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void DataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000002u; +} +inline void DataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000002u; +} +inline void DataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +inline ::google::protobuf::uint32 DataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.batch_size) + return batch_size_; +} +inline void DataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.batch_size) +} + +// optional uint32 rand_skip = 7 [default = 0]; +inline bool DataParameter::has_rand_skip() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void DataParameter::set_has_rand_skip() { + _has_bits_[0] |= 0x00000004u; +} +inline void DataParameter::clear_has_rand_skip() { + _has_bits_[0] &= ~0x00000004u; +} +inline void DataParameter::clear_rand_skip() { + rand_skip_ = 0u; + clear_has_rand_skip(); +} +inline ::google::protobuf::uint32 DataParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.rand_skip) + return rand_skip_; +} +inline void DataParameter::set_rand_skip(::google::protobuf::uint32 value) { + set_has_rand_skip(); + rand_skip_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.rand_skip) +} + +// optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB]; +inline bool DataParameter::has_backend() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void DataParameter::set_has_backend() { + _has_bits_[0] |= 0x00000008u; +} +inline void DataParameter::clear_has_backend() { + _has_bits_[0] &= ~0x00000008u; +} +inline void DataParameter::clear_backend() { + backend_ = 0; + clear_has_backend(); +} +inline ::caffe::DataParameter_DB DataParameter::backend() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.backend) + return static_cast< ::caffe::DataParameter_DB >(backend_); +} +inline void DataParameter::set_backend(::caffe::DataParameter_DB value) { + assert(::caffe::DataParameter_DB_IsValid(value)); + set_has_backend(); + backend_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.backend) +} + +// optional float scale = 2 [default = 1]; +inline bool DataParameter::has_scale() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void DataParameter::set_has_scale() { + _has_bits_[0] |= 0x00000010u; +} +inline void DataParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000010u; +} +inline void DataParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float DataParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.scale) + return scale_; +} +inline void DataParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.scale) +} + +// optional string mean_file = 3; +inline bool DataParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void DataParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000020u; +} +inline void DataParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000020u; +} +inline void DataParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +inline const ::std::string& DataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void DataParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.DataParameter.mean_file) +} +inline void DataParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.DataParameter.mean_file) +} +inline void DataParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.DataParameter.mean_file) +} +inline ::std::string* DataParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.DataParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* DataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.DataParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void DataParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.DataParameter.mean_file) +} + +// optional uint32 crop_size = 5 [default = 0]; +inline bool DataParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void DataParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000040u; +} +inline void DataParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000040u; +} +inline void DataParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +inline ::google::protobuf::uint32 DataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.crop_size) + return crop_size_; +} +inline void DataParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +inline bool DataParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void DataParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000080u; +} +inline void DataParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000080u; +} +inline void DataParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +inline bool DataParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.mirror) + return mirror_; +} +inline void DataParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.mirror) +} + +// optional bool force_encoded_color = 9 [default = false]; +inline bool DataParameter::has_force_encoded_color() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void DataParameter::set_has_force_encoded_color() { + _has_bits_[0] |= 0x00000100u; +} +inline void DataParameter::clear_has_force_encoded_color() { + _has_bits_[0] &= ~0x00000100u; +} +inline void DataParameter::clear_force_encoded_color() { + force_encoded_color_ = false; + clear_has_force_encoded_color(); +} +inline bool DataParameter::force_encoded_color() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.force_encoded_color) + return force_encoded_color_; +} +inline void DataParameter::set_force_encoded_color(bool value) { + set_has_force_encoded_color(); + force_encoded_color_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.force_encoded_color) +} + +// optional uint32 prefetch = 10 [default = 4]; +inline bool DataParameter::has_prefetch() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void DataParameter::set_has_prefetch() { + _has_bits_[0] |= 0x00000200u; +} +inline void DataParameter::clear_has_prefetch() { + _has_bits_[0] &= ~0x00000200u; +} +inline void DataParameter::clear_prefetch() { + prefetch_ = 4u; + clear_has_prefetch(); +} +inline ::google::protobuf::uint32 DataParameter::prefetch() const { + // @@protoc_insertion_point(field_get:caffe.DataParameter.prefetch) + return prefetch_; +} +inline void DataParameter::set_prefetch(::google::protobuf::uint32 value) { + set_has_prefetch(); + prefetch_ = value; + // @@protoc_insertion_point(field_set:caffe.DataParameter.prefetch) +} + +inline const DataParameter* DataParameter::internal_default_instance() { + return &DataParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NonMaximumSuppressionParameter + +// optional float nms_threshold = 1 [default = 0.3]; +inline bool NonMaximumSuppressionParameter::has_nms_threshold() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void NonMaximumSuppressionParameter::set_has_nms_threshold() { + _has_bits_[0] |= 0x00000001u; +} +inline void NonMaximumSuppressionParameter::clear_has_nms_threshold() { + _has_bits_[0] &= ~0x00000001u; +} +inline void NonMaximumSuppressionParameter::clear_nms_threshold() { + nms_threshold_ = 0.3f; + clear_has_nms_threshold(); +} +inline float NonMaximumSuppressionParameter::nms_threshold() const { + // @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.nms_threshold) + return nms_threshold_; +} +inline void NonMaximumSuppressionParameter::set_nms_threshold(float value) { + set_has_nms_threshold(); + nms_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.nms_threshold) +} + +// optional int32 top_k = 2; +inline bool NonMaximumSuppressionParameter::has_top_k() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void NonMaximumSuppressionParameter::set_has_top_k() { + _has_bits_[0] |= 0x00000002u; +} +inline void NonMaximumSuppressionParameter::clear_has_top_k() { + _has_bits_[0] &= ~0x00000002u; +} +inline void NonMaximumSuppressionParameter::clear_top_k() { + top_k_ = 0; + clear_has_top_k(); +} +inline ::google::protobuf::int32 NonMaximumSuppressionParameter::top_k() const { + // @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.top_k) + return top_k_; +} +inline void NonMaximumSuppressionParameter::set_top_k(::google::protobuf::int32 value) { + set_has_top_k(); + top_k_ = value; + // @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.top_k) +} + +// optional float eta = 3 [default = 1]; +inline bool NonMaximumSuppressionParameter::has_eta() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void NonMaximumSuppressionParameter::set_has_eta() { + _has_bits_[0] |= 0x00000004u; +} +inline void NonMaximumSuppressionParameter::clear_has_eta() { + _has_bits_[0] &= ~0x00000004u; +} +inline void NonMaximumSuppressionParameter::clear_eta() { + eta_ = 1; + clear_has_eta(); +} +inline float NonMaximumSuppressionParameter::eta() const { + // @@protoc_insertion_point(field_get:caffe.NonMaximumSuppressionParameter.eta) + return eta_; +} +inline void NonMaximumSuppressionParameter::set_eta(float value) { + set_has_eta(); + eta_ = value; + // @@protoc_insertion_point(field_set:caffe.NonMaximumSuppressionParameter.eta) +} + +inline const NonMaximumSuppressionParameter* NonMaximumSuppressionParameter::internal_default_instance() { + return &NonMaximumSuppressionParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// SaveOutputParameter + +// optional string output_directory = 1; +inline bool SaveOutputParameter::has_output_directory() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SaveOutputParameter::set_has_output_directory() { + _has_bits_[0] |= 0x00000001u; +} +inline void SaveOutputParameter::clear_has_output_directory() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SaveOutputParameter::clear_output_directory() { + output_directory_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_output_directory(); +} +inline const ::std::string& SaveOutputParameter::output_directory() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_directory) + return output_directory_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_output_directory(const ::std::string& value) { + set_has_output_directory(); + output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_directory) +} +inline void SaveOutputParameter::set_output_directory(const char* value) { + set_has_output_directory(); + output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.output_directory) +} +inline void SaveOutputParameter::set_output_directory(const char* value, size_t size) { + set_has_output_directory(); + output_directory_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.output_directory) +} +inline ::std::string* SaveOutputParameter::mutable_output_directory() { + set_has_output_directory(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_directory) + return output_directory_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SaveOutputParameter::release_output_directory() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_directory) + clear_has_output_directory(); + return output_directory_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_allocated_output_directory(::std::string* output_directory) { + if (output_directory != NULL) { + set_has_output_directory(); + } else { + clear_has_output_directory(); + } + output_directory_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_directory); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_directory) +} + +// optional string output_name_prefix = 2; +inline bool SaveOutputParameter::has_output_name_prefix() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SaveOutputParameter::set_has_output_name_prefix() { + _has_bits_[0] |= 0x00000002u; +} +inline void SaveOutputParameter::clear_has_output_name_prefix() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SaveOutputParameter::clear_output_name_prefix() { + output_name_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_output_name_prefix(); +} +inline const ::std::string& SaveOutputParameter::output_name_prefix() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_name_prefix) + return output_name_prefix_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_output_name_prefix(const ::std::string& value) { + set_has_output_name_prefix(); + output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_name_prefix) +} +inline void SaveOutputParameter::set_output_name_prefix(const char* value) { + set_has_output_name_prefix(); + output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.output_name_prefix) +} +inline void SaveOutputParameter::set_output_name_prefix(const char* value, size_t size) { + set_has_output_name_prefix(); + output_name_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.output_name_prefix) +} +inline ::std::string* SaveOutputParameter::mutable_output_name_prefix() { + set_has_output_name_prefix(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_name_prefix) + return output_name_prefix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SaveOutputParameter::release_output_name_prefix() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_name_prefix) + clear_has_output_name_prefix(); + return output_name_prefix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_allocated_output_name_prefix(::std::string* output_name_prefix) { + if (output_name_prefix != NULL) { + set_has_output_name_prefix(); + } else { + clear_has_output_name_prefix(); + } + output_name_prefix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_name_prefix); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_name_prefix) +} + +// optional string output_format = 3; +inline bool SaveOutputParameter::has_output_format() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SaveOutputParameter::set_has_output_format() { + _has_bits_[0] |= 0x00000004u; +} +inline void SaveOutputParameter::clear_has_output_format() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SaveOutputParameter::clear_output_format() { + output_format_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_output_format(); +} +inline const ::std::string& SaveOutputParameter::output_format() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.output_format) + return output_format_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_output_format(const ::std::string& value) { + set_has_output_format(); + output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.output_format) +} +inline void SaveOutputParameter::set_output_format(const char* value) { + set_has_output_format(); + output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.output_format) +} +inline void SaveOutputParameter::set_output_format(const char* value, size_t size) { + set_has_output_format(); + output_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.output_format) +} +inline ::std::string* SaveOutputParameter::mutable_output_format() { + set_has_output_format(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.output_format) + return output_format_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SaveOutputParameter::release_output_format() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.output_format) + clear_has_output_format(); + return output_format_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_allocated_output_format(::std::string* output_format) { + if (output_format != NULL) { + set_has_output_format(); + } else { + clear_has_output_format(); + } + output_format_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_format); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.output_format) +} + +// optional string label_map_file = 4; +inline bool SaveOutputParameter::has_label_map_file() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void SaveOutputParameter::set_has_label_map_file() { + _has_bits_[0] |= 0x00000008u; +} +inline void SaveOutputParameter::clear_has_label_map_file() { + _has_bits_[0] &= ~0x00000008u; +} +inline void SaveOutputParameter::clear_label_map_file() { + label_map_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_label_map_file(); +} +inline const ::std::string& SaveOutputParameter::label_map_file() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.label_map_file) + return label_map_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_label_map_file(const ::std::string& value) { + set_has_label_map_file(); + label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.label_map_file) +} +inline void SaveOutputParameter::set_label_map_file(const char* value) { + set_has_label_map_file(); + label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.label_map_file) +} +inline void SaveOutputParameter::set_label_map_file(const char* value, size_t size) { + set_has_label_map_file(); + label_map_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.label_map_file) +} +inline ::std::string* SaveOutputParameter::mutable_label_map_file() { + set_has_label_map_file(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.label_map_file) + return label_map_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SaveOutputParameter::release_label_map_file() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.label_map_file) + clear_has_label_map_file(); + return label_map_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_allocated_label_map_file(::std::string* label_map_file) { + if (label_map_file != NULL) { + set_has_label_map_file(); + } else { + clear_has_label_map_file(); + } + label_map_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), label_map_file); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.label_map_file) +} + +// optional string name_size_file = 5; +inline bool SaveOutputParameter::has_name_size_file() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SaveOutputParameter::set_has_name_size_file() { + _has_bits_[0] |= 0x00000010u; +} +inline void SaveOutputParameter::clear_has_name_size_file() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SaveOutputParameter::clear_name_size_file() { + name_size_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name_size_file(); +} +inline const ::std::string& SaveOutputParameter::name_size_file() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.name_size_file) + return name_size_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_name_size_file(const ::std::string& value) { + set_has_name_size_file(); + name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.name_size_file) +} +inline void SaveOutputParameter::set_name_size_file(const char* value) { + set_has_name_size_file(); + name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.SaveOutputParameter.name_size_file) +} +inline void SaveOutputParameter::set_name_size_file(const char* value, size_t size) { + set_has_name_size_file(); + name_size_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.SaveOutputParameter.name_size_file) +} +inline ::std::string* SaveOutputParameter::mutable_name_size_file() { + set_has_name_size_file(); + // @@protoc_insertion_point(field_mutable:caffe.SaveOutputParameter.name_size_file) + return name_size_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* SaveOutputParameter::release_name_size_file() { + // @@protoc_insertion_point(field_release:caffe.SaveOutputParameter.name_size_file) + clear_has_name_size_file(); + return name_size_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void SaveOutputParameter::set_allocated_name_size_file(::std::string* name_size_file) { + if (name_size_file != NULL) { + set_has_name_size_file(); + } else { + clear_has_name_size_file(); + } + name_size_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name_size_file); + // @@protoc_insertion_point(field_set_allocated:caffe.SaveOutputParameter.name_size_file) +} + +// optional uint32 num_test_image = 6; +inline bool SaveOutputParameter::has_num_test_image() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void SaveOutputParameter::set_has_num_test_image() { + _has_bits_[0] |= 0x00000020u; +} +inline void SaveOutputParameter::clear_has_num_test_image() { + _has_bits_[0] &= ~0x00000020u; +} +inline void SaveOutputParameter::clear_num_test_image() { + num_test_image_ = 0u; + clear_has_num_test_image(); +} +inline ::google::protobuf::uint32 SaveOutputParameter::num_test_image() const { + // @@protoc_insertion_point(field_get:caffe.SaveOutputParameter.num_test_image) + return num_test_image_; +} +inline void SaveOutputParameter::set_num_test_image(::google::protobuf::uint32 value) { + set_has_num_test_image(); + num_test_image_ = value; + // @@protoc_insertion_point(field_set:caffe.SaveOutputParameter.num_test_image) +} + +inline const SaveOutputParameter* SaveOutputParameter::internal_default_instance() { + return &SaveOutputParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// DropoutParameter + +// optional float dropout_ratio = 1 [default = 0.5]; +inline bool DropoutParameter::has_dropout_ratio() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DropoutParameter::set_has_dropout_ratio() { + _has_bits_[0] |= 0x00000001u; +} +inline void DropoutParameter::clear_has_dropout_ratio() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DropoutParameter::clear_dropout_ratio() { + dropout_ratio_ = 0.5f; + clear_has_dropout_ratio(); +} +inline float DropoutParameter::dropout_ratio() const { + // @@protoc_insertion_point(field_get:caffe.DropoutParameter.dropout_ratio) + return dropout_ratio_; +} +inline void DropoutParameter::set_dropout_ratio(float value) { + set_has_dropout_ratio(); + dropout_ratio_ = value; + // @@protoc_insertion_point(field_set:caffe.DropoutParameter.dropout_ratio) +} + +inline const DropoutParameter* DropoutParameter::internal_default_instance() { + return &DropoutParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// DummyDataParameter + +// repeated .caffe.FillerParameter data_filler = 1; +inline int DummyDataParameter::data_filler_size() const { + return data_filler_.size(); +} +inline void DummyDataParameter::clear_data_filler() { + data_filler_.Clear(); +} +inline const ::caffe::FillerParameter& DummyDataParameter::data_filler(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.data_filler) + return data_filler_.Get(index); +} +inline ::caffe::FillerParameter* DummyDataParameter::mutable_data_filler(int index) { + // @@protoc_insertion_point(field_mutable:caffe.DummyDataParameter.data_filler) + return data_filler_.Mutable(index); +} +inline ::caffe::FillerParameter* DummyDataParameter::add_data_filler() { + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.data_filler) + return data_filler_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >* +DummyDataParameter::mutable_data_filler() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.data_filler) + return &data_filler_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >& +DummyDataParameter::data_filler() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.data_filler) + return data_filler_; +} + +// repeated .caffe.BlobShape shape = 6; +inline int DummyDataParameter::shape_size() const { + return shape_.size(); +} +inline void DummyDataParameter::clear_shape() { + shape_.Clear(); +} +inline const ::caffe::BlobShape& DummyDataParameter::shape(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.shape) + return shape_.Get(index); +} +inline ::caffe::BlobShape* DummyDataParameter::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:caffe.DummyDataParameter.shape) + return shape_.Mutable(index); +} +inline ::caffe::BlobShape* DummyDataParameter::add_shape() { + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.shape) + return shape_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* +DummyDataParameter::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.shape) + return &shape_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& +DummyDataParameter::shape() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.shape) + return shape_; +} + +// repeated uint32 num = 2; +inline int DummyDataParameter::num_size() const { + return num_.size(); +} +inline void DummyDataParameter::clear_num() { + num_.Clear(); +} +inline ::google::protobuf::uint32 DummyDataParameter::num(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.num) + return num_.Get(index); +} +inline void DummyDataParameter::set_num(int index, ::google::protobuf::uint32 value) { + num_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.num) +} +inline void DummyDataParameter::add_num(::google::protobuf::uint32 value) { + num_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.num) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::num() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.num) + return num_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_num() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.num) + return &num_; +} + +// repeated uint32 channels = 3; +inline int DummyDataParameter::channels_size() const { + return channels_.size(); +} +inline void DummyDataParameter::clear_channels() { + channels_.Clear(); +} +inline ::google::protobuf::uint32 DummyDataParameter::channels(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.channels) + return channels_.Get(index); +} +inline void DummyDataParameter::set_channels(int index, ::google::protobuf::uint32 value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.channels) +} +inline void DummyDataParameter::add_channels(::google::protobuf::uint32 value) { + channels_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.channels) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::channels() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.channels) + return channels_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.channels) + return &channels_; +} + +// repeated uint32 height = 4; +inline int DummyDataParameter::height_size() const { + return height_.size(); +} +inline void DummyDataParameter::clear_height() { + height_.Clear(); +} +inline ::google::protobuf::uint32 DummyDataParameter::height(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.height) + return height_.Get(index); +} +inline void DummyDataParameter::set_height(int index, ::google::protobuf::uint32 value) { + height_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.height) +} +inline void DummyDataParameter::add_height(::google::protobuf::uint32 value) { + height_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.height) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::height() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.height) + return height_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_height() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.height) + return &height_; +} + +// repeated uint32 width = 5; +inline int DummyDataParameter::width_size() const { + return width_.size(); +} +inline void DummyDataParameter::clear_width() { + width_.Clear(); +} +inline ::google::protobuf::uint32 DummyDataParameter::width(int index) const { + // @@protoc_insertion_point(field_get:caffe.DummyDataParameter.width) + return width_.Get(index); +} +inline void DummyDataParameter::set_width(int index, ::google::protobuf::uint32 value) { + width_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.DummyDataParameter.width) +} +inline void DummyDataParameter::add_width(::google::protobuf::uint32 value) { + width_.Add(value); + // @@protoc_insertion_point(field_add:caffe.DummyDataParameter.width) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +DummyDataParameter::width() const { + // @@protoc_insertion_point(field_list:caffe.DummyDataParameter.width) + return width_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +DummyDataParameter::mutable_width() { + // @@protoc_insertion_point(field_mutable_list:caffe.DummyDataParameter.width) + return &width_; +} + +inline const DummyDataParameter* DummyDataParameter::internal_default_instance() { + return &DummyDataParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// EltwiseParameter + +// optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM]; +inline bool EltwiseParameter::has_operation() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void EltwiseParameter::set_has_operation() { + _has_bits_[0] |= 0x00000001u; +} +inline void EltwiseParameter::clear_has_operation() { + _has_bits_[0] &= ~0x00000001u; +} +inline void EltwiseParameter::clear_operation() { + operation_ = 1; + clear_has_operation(); +} +inline ::caffe::EltwiseParameter_EltwiseOp EltwiseParameter::operation() const { + // @@protoc_insertion_point(field_get:caffe.EltwiseParameter.operation) + return static_cast< ::caffe::EltwiseParameter_EltwiseOp >(operation_); +} +inline void EltwiseParameter::set_operation(::caffe::EltwiseParameter_EltwiseOp value) { + assert(::caffe::EltwiseParameter_EltwiseOp_IsValid(value)); + set_has_operation(); + operation_ = value; + // @@protoc_insertion_point(field_set:caffe.EltwiseParameter.operation) +} + +// repeated float coeff = 2; +inline int EltwiseParameter::coeff_size() const { + return coeff_.size(); +} +inline void EltwiseParameter::clear_coeff() { + coeff_.Clear(); +} +inline float EltwiseParameter::coeff(int index) const { + // @@protoc_insertion_point(field_get:caffe.EltwiseParameter.coeff) + return coeff_.Get(index); +} +inline void EltwiseParameter::set_coeff(int index, float value) { + coeff_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.EltwiseParameter.coeff) +} +inline void EltwiseParameter::add_coeff(float value) { + coeff_.Add(value); + // @@protoc_insertion_point(field_add:caffe.EltwiseParameter.coeff) +} +inline const ::google::protobuf::RepeatedField< float >& +EltwiseParameter::coeff() const { + // @@protoc_insertion_point(field_list:caffe.EltwiseParameter.coeff) + return coeff_; +} +inline ::google::protobuf::RepeatedField< float >* +EltwiseParameter::mutable_coeff() { + // @@protoc_insertion_point(field_mutable_list:caffe.EltwiseParameter.coeff) + return &coeff_; +} + +// optional bool stable_prod_grad = 3 [default = true]; +inline bool EltwiseParameter::has_stable_prod_grad() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void EltwiseParameter::set_has_stable_prod_grad() { + _has_bits_[0] |= 0x00000004u; +} +inline void EltwiseParameter::clear_has_stable_prod_grad() { + _has_bits_[0] &= ~0x00000004u; +} +inline void EltwiseParameter::clear_stable_prod_grad() { + stable_prod_grad_ = true; + clear_has_stable_prod_grad(); +} +inline bool EltwiseParameter::stable_prod_grad() const { + // @@protoc_insertion_point(field_get:caffe.EltwiseParameter.stable_prod_grad) + return stable_prod_grad_; +} +inline void EltwiseParameter::set_stable_prod_grad(bool value) { + set_has_stable_prod_grad(); + stable_prod_grad_ = value; + // @@protoc_insertion_point(field_set:caffe.EltwiseParameter.stable_prod_grad) +} + +inline const EltwiseParameter* EltwiseParameter::internal_default_instance() { + return &EltwiseParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ELUParameter + +// optional float alpha = 1 [default = 1]; +inline bool ELUParameter::has_alpha() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ELUParameter::set_has_alpha() { + _has_bits_[0] |= 0x00000001u; +} +inline void ELUParameter::clear_has_alpha() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ELUParameter::clear_alpha() { + alpha_ = 1; + clear_has_alpha(); +} +inline float ELUParameter::alpha() const { + // @@protoc_insertion_point(field_get:caffe.ELUParameter.alpha) + return alpha_; +} +inline void ELUParameter::set_alpha(float value) { + set_has_alpha(); + alpha_ = value; + // @@protoc_insertion_point(field_set:caffe.ELUParameter.alpha) +} + +inline const ELUParameter* ELUParameter::internal_default_instance() { + return &ELUParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// EmbedParameter + +// optional uint32 num_output = 1; +inline bool EmbedParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void EmbedParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +inline void EmbedParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +inline void EmbedParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +inline ::google::protobuf::uint32 EmbedParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.num_output) + return num_output_; +} +inline void EmbedParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.EmbedParameter.num_output) +} + +// optional uint32 input_dim = 2; +inline bool EmbedParameter::has_input_dim() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void EmbedParameter::set_has_input_dim() { + _has_bits_[0] |= 0x00000002u; +} +inline void EmbedParameter::clear_has_input_dim() { + _has_bits_[0] &= ~0x00000002u; +} +inline void EmbedParameter::clear_input_dim() { + input_dim_ = 0u; + clear_has_input_dim(); +} +inline ::google::protobuf::uint32 EmbedParameter::input_dim() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.input_dim) + return input_dim_; +} +inline void EmbedParameter::set_input_dim(::google::protobuf::uint32 value) { + set_has_input_dim(); + input_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.EmbedParameter.input_dim) +} + +// optional bool bias_term = 3 [default = true]; +inline bool EmbedParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void EmbedParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000004u; +} +inline void EmbedParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000004u; +} +inline void EmbedParameter::clear_bias_term() { + bias_term_ = true; + clear_has_bias_term(); +} +inline bool EmbedParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.bias_term) + return bias_term_; +} +inline void EmbedParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.EmbedParameter.bias_term) +} + +// optional .caffe.FillerParameter weight_filler = 4; +inline bool EmbedParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void EmbedParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000008u; +} +inline void EmbedParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000008u; +} +inline void EmbedParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +inline const ::caffe::FillerParameter& EmbedParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* EmbedParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.EmbedParameter.weight_filler) + return weight_filler_; +} +inline ::caffe::FillerParameter* EmbedParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.EmbedParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +inline void EmbedParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.EmbedParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 5; +inline bool EmbedParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void EmbedParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000010u; +} +inline void EmbedParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000010u; +} +inline void EmbedParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +inline const ::caffe::FillerParameter& EmbedParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.EmbedParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* EmbedParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.EmbedParameter.bias_filler) + return bias_filler_; +} +inline ::caffe::FillerParameter* EmbedParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.EmbedParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +inline void EmbedParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.EmbedParameter.bias_filler) +} + +inline const EmbedParameter* EmbedParameter::internal_default_instance() { + return &EmbedParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ExpParameter + +// optional float base = 1 [default = -1]; +inline bool ExpParameter::has_base() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ExpParameter::set_has_base() { + _has_bits_[0] |= 0x00000001u; +} +inline void ExpParameter::clear_has_base() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ExpParameter::clear_base() { + base_ = -1; + clear_has_base(); +} +inline float ExpParameter::base() const { + // @@protoc_insertion_point(field_get:caffe.ExpParameter.base) + return base_; +} +inline void ExpParameter::set_base(float value) { + set_has_base(); + base_ = value; + // @@protoc_insertion_point(field_set:caffe.ExpParameter.base) +} + +// optional float scale = 2 [default = 1]; +inline bool ExpParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ExpParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +inline void ExpParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ExpParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float ExpParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.ExpParameter.scale) + return scale_; +} +inline void ExpParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.ExpParameter.scale) +} + +// optional float shift = 3 [default = 0]; +inline bool ExpParameter::has_shift() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ExpParameter::set_has_shift() { + _has_bits_[0] |= 0x00000004u; +} +inline void ExpParameter::clear_has_shift() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ExpParameter::clear_shift() { + shift_ = 0; + clear_has_shift(); +} +inline float ExpParameter::shift() const { + // @@protoc_insertion_point(field_get:caffe.ExpParameter.shift) + return shift_; +} +inline void ExpParameter::set_shift(float value) { + set_has_shift(); + shift_ = value; + // @@protoc_insertion_point(field_set:caffe.ExpParameter.shift) +} + +inline const ExpParameter* ExpParameter::internal_default_instance() { + return &ExpParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// FlattenParameter + +// optional int32 axis = 1 [default = 1]; +inline bool FlattenParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FlattenParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +inline void FlattenParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FlattenParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 FlattenParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.FlattenParameter.axis) + return axis_; +} +inline void FlattenParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.FlattenParameter.axis) +} + +// optional int32 end_axis = 2 [default = -1]; +inline bool FlattenParameter::has_end_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FlattenParameter::set_has_end_axis() { + _has_bits_[0] |= 0x00000002u; +} +inline void FlattenParameter::clear_has_end_axis() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FlattenParameter::clear_end_axis() { + end_axis_ = -1; + clear_has_end_axis(); +} +inline ::google::protobuf::int32 FlattenParameter::end_axis() const { + // @@protoc_insertion_point(field_get:caffe.FlattenParameter.end_axis) + return end_axis_; +} +inline void FlattenParameter::set_end_axis(::google::protobuf::int32 value) { + set_has_end_axis(); + end_axis_ = value; + // @@protoc_insertion_point(field_set:caffe.FlattenParameter.end_axis) +} + +inline const FlattenParameter* FlattenParameter::internal_default_instance() { + return &FlattenParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// HDF5DataParameter + +// optional string source = 1; +inline bool HDF5DataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void HDF5DataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +inline void HDF5DataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +inline void HDF5DataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +inline const ::std::string& HDF5DataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void HDF5DataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.source) +} +inline void HDF5DataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.HDF5DataParameter.source) +} +inline void HDF5DataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.HDF5DataParameter.source) +} +inline ::std::string* HDF5DataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.HDF5DataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* HDF5DataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.HDF5DataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void HDF5DataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.HDF5DataParameter.source) +} + +// optional uint32 batch_size = 2; +inline bool HDF5DataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void HDF5DataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000002u; +} +inline void HDF5DataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000002u; +} +inline void HDF5DataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +inline ::google::protobuf::uint32 HDF5DataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.batch_size) + return batch_size_; +} +inline void HDF5DataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.batch_size) +} + +// optional bool shuffle = 3 [default = false]; +inline bool HDF5DataParameter::has_shuffle() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void HDF5DataParameter::set_has_shuffle() { + _has_bits_[0] |= 0x00000004u; +} +inline void HDF5DataParameter::clear_has_shuffle() { + _has_bits_[0] &= ~0x00000004u; +} +inline void HDF5DataParameter::clear_shuffle() { + shuffle_ = false; + clear_has_shuffle(); +} +inline bool HDF5DataParameter::shuffle() const { + // @@protoc_insertion_point(field_get:caffe.HDF5DataParameter.shuffle) + return shuffle_; +} +inline void HDF5DataParameter::set_shuffle(bool value) { + set_has_shuffle(); + shuffle_ = value; + // @@protoc_insertion_point(field_set:caffe.HDF5DataParameter.shuffle) +} + +inline const HDF5DataParameter* HDF5DataParameter::internal_default_instance() { + return &HDF5DataParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// HDF5OutputParameter + +// optional string file_name = 1; +inline bool HDF5OutputParameter::has_file_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void HDF5OutputParameter::set_has_file_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void HDF5OutputParameter::clear_has_file_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void HDF5OutputParameter::clear_file_name() { + file_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_file_name(); +} +inline const ::std::string& HDF5OutputParameter::file_name() const { + // @@protoc_insertion_point(field_get:caffe.HDF5OutputParameter.file_name) + return file_name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void HDF5OutputParameter::set_file_name(const ::std::string& value) { + set_has_file_name(); + file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.HDF5OutputParameter.file_name) +} +inline void HDF5OutputParameter::set_file_name(const char* value) { + set_has_file_name(); + file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.HDF5OutputParameter.file_name) +} +inline void HDF5OutputParameter::set_file_name(const char* value, size_t size) { + set_has_file_name(); + file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.HDF5OutputParameter.file_name) +} +inline ::std::string* HDF5OutputParameter::mutable_file_name() { + set_has_file_name(); + // @@protoc_insertion_point(field_mutable:caffe.HDF5OutputParameter.file_name) + return file_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* HDF5OutputParameter::release_file_name() { + // @@protoc_insertion_point(field_release:caffe.HDF5OutputParameter.file_name) + clear_has_file_name(); + return file_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void HDF5OutputParameter::set_allocated_file_name(::std::string* file_name) { + if (file_name != NULL) { + set_has_file_name(); + } else { + clear_has_file_name(); + } + file_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), file_name); + // @@protoc_insertion_point(field_set_allocated:caffe.HDF5OutputParameter.file_name) +} + +inline const HDF5OutputParameter* HDF5OutputParameter::internal_default_instance() { + return &HDF5OutputParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// HingeLossParameter + +// optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1]; +inline bool HingeLossParameter::has_norm() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void HingeLossParameter::set_has_norm() { + _has_bits_[0] |= 0x00000001u; +} +inline void HingeLossParameter::clear_has_norm() { + _has_bits_[0] &= ~0x00000001u; +} +inline void HingeLossParameter::clear_norm() { + norm_ = 1; + clear_has_norm(); +} +inline ::caffe::HingeLossParameter_Norm HingeLossParameter::norm() const { + // @@protoc_insertion_point(field_get:caffe.HingeLossParameter.norm) + return static_cast< ::caffe::HingeLossParameter_Norm >(norm_); +} +inline void HingeLossParameter::set_norm(::caffe::HingeLossParameter_Norm value) { + assert(::caffe::HingeLossParameter_Norm_IsValid(value)); + set_has_norm(); + norm_ = value; + // @@protoc_insertion_point(field_set:caffe.HingeLossParameter.norm) +} + +inline const HingeLossParameter* HingeLossParameter::internal_default_instance() { + return &HingeLossParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ImageDataParameter + +// optional string source = 1; +inline bool ImageDataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ImageDataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +inline void ImageDataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ImageDataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +inline const ::std::string& ImageDataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageDataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.source) +} +inline void ImageDataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ImageDataParameter.source) +} +inline void ImageDataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ImageDataParameter.source) +} +inline ::std::string* ImageDataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* ImageDataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.ImageDataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageDataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.source) +} + +// optional uint32 batch_size = 4 [default = 1]; +inline bool ImageDataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ImageDataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000002u; +} +inline void ImageDataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ImageDataParameter::clear_batch_size() { + batch_size_ = 1u; + clear_has_batch_size(); +} +inline ::google::protobuf::uint32 ImageDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.batch_size) + return batch_size_; +} +inline void ImageDataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.batch_size) +} + +// optional uint32 rand_skip = 7 [default = 0]; +inline bool ImageDataParameter::has_rand_skip() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ImageDataParameter::set_has_rand_skip() { + _has_bits_[0] |= 0x00000004u; +} +inline void ImageDataParameter::clear_has_rand_skip() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ImageDataParameter::clear_rand_skip() { + rand_skip_ = 0u; + clear_has_rand_skip(); +} +inline ::google::protobuf::uint32 ImageDataParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.rand_skip) + return rand_skip_; +} +inline void ImageDataParameter::set_rand_skip(::google::protobuf::uint32 value) { + set_has_rand_skip(); + rand_skip_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.rand_skip) +} + +// optional bool shuffle = 8 [default = false]; +inline bool ImageDataParameter::has_shuffle() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ImageDataParameter::set_has_shuffle() { + _has_bits_[0] |= 0x00000008u; +} +inline void ImageDataParameter::clear_has_shuffle() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ImageDataParameter::clear_shuffle() { + shuffle_ = false; + clear_has_shuffle(); +} +inline bool ImageDataParameter::shuffle() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.shuffle) + return shuffle_; +} +inline void ImageDataParameter::set_shuffle(bool value) { + set_has_shuffle(); + shuffle_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.shuffle) +} + +// optional uint32 new_height = 9 [default = 0]; +inline bool ImageDataParameter::has_new_height() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ImageDataParameter::set_has_new_height() { + _has_bits_[0] |= 0x00000010u; +} +inline void ImageDataParameter::clear_has_new_height() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ImageDataParameter::clear_new_height() { + new_height_ = 0u; + clear_has_new_height(); +} +inline ::google::protobuf::uint32 ImageDataParameter::new_height() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.new_height) + return new_height_; +} +inline void ImageDataParameter::set_new_height(::google::protobuf::uint32 value) { + set_has_new_height(); + new_height_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.new_height) +} + +// optional uint32 new_width = 10 [default = 0]; +inline bool ImageDataParameter::has_new_width() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ImageDataParameter::set_has_new_width() { + _has_bits_[0] |= 0x00000020u; +} +inline void ImageDataParameter::clear_has_new_width() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ImageDataParameter::clear_new_width() { + new_width_ = 0u; + clear_has_new_width(); +} +inline ::google::protobuf::uint32 ImageDataParameter::new_width() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.new_width) + return new_width_; +} +inline void ImageDataParameter::set_new_width(::google::protobuf::uint32 value) { + set_has_new_width(); + new_width_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.new_width) +} + +// optional bool is_color = 11 [default = true]; +inline bool ImageDataParameter::has_is_color() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void ImageDataParameter::set_has_is_color() { + _has_bits_[0] |= 0x00000040u; +} +inline void ImageDataParameter::clear_has_is_color() { + _has_bits_[0] &= ~0x00000040u; +} +inline void ImageDataParameter::clear_is_color() { + is_color_ = true; + clear_has_is_color(); +} +inline bool ImageDataParameter::is_color() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.is_color) + return is_color_; +} +inline void ImageDataParameter::set_is_color(bool value) { + set_has_is_color(); + is_color_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.is_color) +} + +// optional float scale = 2 [default = 1]; +inline bool ImageDataParameter::has_scale() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void ImageDataParameter::set_has_scale() { + _has_bits_[0] |= 0x00000080u; +} +inline void ImageDataParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000080u; +} +inline void ImageDataParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float ImageDataParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.scale) + return scale_; +} +inline void ImageDataParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.scale) +} + +// optional string mean_file = 3; +inline bool ImageDataParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void ImageDataParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000100u; +} +inline void ImageDataParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000100u; +} +inline void ImageDataParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +inline const ::std::string& ImageDataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageDataParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.mean_file) +} +inline void ImageDataParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ImageDataParameter.mean_file) +} +inline void ImageDataParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ImageDataParameter.mean_file) +} +inline ::std::string* ImageDataParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* ImageDataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.ImageDataParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageDataParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.mean_file) +} + +// optional uint32 crop_size = 5 [default = 0]; +inline bool ImageDataParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void ImageDataParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000200u; +} +inline void ImageDataParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000200u; +} +inline void ImageDataParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +inline ::google::protobuf::uint32 ImageDataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.crop_size) + return crop_size_; +} +inline void ImageDataParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +inline bool ImageDataParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void ImageDataParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000400u; +} +inline void ImageDataParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000400u; +} +inline void ImageDataParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +inline bool ImageDataParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.mirror) + return mirror_; +} +inline void ImageDataParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.mirror) +} + +// optional string root_folder = 12 [default = ""]; +inline bool ImageDataParameter::has_root_folder() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void ImageDataParameter::set_has_root_folder() { + _has_bits_[0] |= 0x00000800u; +} +inline void ImageDataParameter::clear_has_root_folder() { + _has_bits_[0] &= ~0x00000800u; +} +inline void ImageDataParameter::clear_root_folder() { + root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_root_folder(); +} +inline const ::std::string& ImageDataParameter::root_folder() const { + // @@protoc_insertion_point(field_get:caffe.ImageDataParameter.root_folder) + return root_folder_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageDataParameter::set_root_folder(const ::std::string& value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.ImageDataParameter.root_folder) +} +inline void ImageDataParameter::set_root_folder(const char* value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.ImageDataParameter.root_folder) +} +inline void ImageDataParameter::set_root_folder(const char* value, size_t size) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.ImageDataParameter.root_folder) +} +inline ::std::string* ImageDataParameter::mutable_root_folder() { + set_has_root_folder(); + // @@protoc_insertion_point(field_mutable:caffe.ImageDataParameter.root_folder) + return root_folder_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* ImageDataParameter::release_root_folder() { + // @@protoc_insertion_point(field_release:caffe.ImageDataParameter.root_folder) + clear_has_root_folder(); + return root_folder_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageDataParameter::set_allocated_root_folder(::std::string* root_folder) { + if (root_folder != NULL) { + set_has_root_folder(); + } else { + clear_has_root_folder(); + } + root_folder_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root_folder); + // @@protoc_insertion_point(field_set_allocated:caffe.ImageDataParameter.root_folder) +} + +inline const ImageDataParameter* ImageDataParameter::internal_default_instance() { + return &ImageDataParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// InfogainLossParameter + +// optional string source = 1; +inline bool InfogainLossParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InfogainLossParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +inline void InfogainLossParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InfogainLossParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +inline const ::std::string& InfogainLossParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.InfogainLossParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void InfogainLossParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.InfogainLossParameter.source) +} +inline void InfogainLossParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.InfogainLossParameter.source) +} +inline void InfogainLossParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.InfogainLossParameter.source) +} +inline ::std::string* InfogainLossParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.InfogainLossParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* InfogainLossParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.InfogainLossParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void InfogainLossParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.InfogainLossParameter.source) +} + +inline const InfogainLossParameter* InfogainLossParameter::internal_default_instance() { + return &InfogainLossParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// InnerProductParameter + +// optional uint32 num_output = 1; +inline bool InnerProductParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InnerProductParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +inline void InnerProductParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InnerProductParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +inline ::google::protobuf::uint32 InnerProductParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.num_output) + return num_output_; +} +inline void InnerProductParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.num_output) +} + +// optional bool bias_term = 2 [default = true]; +inline bool InnerProductParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void InnerProductParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000002u; +} +inline void InnerProductParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000002u; +} +inline void InnerProductParameter::clear_bias_term() { + bias_term_ = true; + clear_has_bias_term(); +} +inline bool InnerProductParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.bias_term) + return bias_term_; +} +inline void InnerProductParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.bias_term) +} + +// optional .caffe.FillerParameter weight_filler = 3; +inline bool InnerProductParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void InnerProductParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000004u; +} +inline void InnerProductParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000004u; +} +inline void InnerProductParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +inline const ::caffe::FillerParameter& InnerProductParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* InnerProductParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.InnerProductParameter.weight_filler) + return weight_filler_; +} +inline ::caffe::FillerParameter* InnerProductParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.InnerProductParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +inline void InnerProductParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.InnerProductParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 4; +inline bool InnerProductParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void InnerProductParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000008u; +} +inline void InnerProductParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000008u; +} +inline void InnerProductParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +inline const ::caffe::FillerParameter& InnerProductParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* InnerProductParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.InnerProductParameter.bias_filler) + return bias_filler_; +} +inline ::caffe::FillerParameter* InnerProductParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.InnerProductParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +inline void InnerProductParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.InnerProductParameter.bias_filler) +} + +// optional int32 axis = 5 [default = 1]; +inline bool InnerProductParameter::has_axis() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void InnerProductParameter::set_has_axis() { + _has_bits_[0] |= 0x00000010u; +} +inline void InnerProductParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000010u; +} +inline void InnerProductParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 InnerProductParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.axis) + return axis_; +} +inline void InnerProductParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.axis) +} + +// optional bool transpose = 6 [default = false]; +inline bool InnerProductParameter::has_transpose() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void InnerProductParameter::set_has_transpose() { + _has_bits_[0] |= 0x00000020u; +} +inline void InnerProductParameter::clear_has_transpose() { + _has_bits_[0] &= ~0x00000020u; +} +inline void InnerProductParameter::clear_transpose() { + transpose_ = false; + clear_has_transpose(); +} +inline bool InnerProductParameter::transpose() const { + // @@protoc_insertion_point(field_get:caffe.InnerProductParameter.transpose) + return transpose_; +} +inline void InnerProductParameter::set_transpose(bool value) { + set_has_transpose(); + transpose_ = value; + // @@protoc_insertion_point(field_set:caffe.InnerProductParameter.transpose) +} + +inline const InnerProductParameter* InnerProductParameter::internal_default_instance() { + return &InnerProductParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// InputParameter + +// repeated .caffe.BlobShape shape = 1; +inline int InputParameter::shape_size() const { + return shape_.size(); +} +inline void InputParameter::clear_shape() { + shape_.Clear(); +} +inline const ::caffe::BlobShape& InputParameter::shape(int index) const { + // @@protoc_insertion_point(field_get:caffe.InputParameter.shape) + return shape_.Get(index); +} +inline ::caffe::BlobShape* InputParameter::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:caffe.InputParameter.shape) + return shape_.Mutable(index); +} +inline ::caffe::BlobShape* InputParameter::add_shape() { + // @@protoc_insertion_point(field_add:caffe.InputParameter.shape) + return shape_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >* +InputParameter::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:caffe.InputParameter.shape) + return &shape_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobShape >& +InputParameter::shape() const { + // @@protoc_insertion_point(field_list:caffe.InputParameter.shape) + return shape_; +} + +inline const InputParameter* InputParameter::internal_default_instance() { + return &InputParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// LogParameter + +// optional float base = 1 [default = -1]; +inline bool LogParameter::has_base() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LogParameter::set_has_base() { + _has_bits_[0] |= 0x00000001u; +} +inline void LogParameter::clear_has_base() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LogParameter::clear_base() { + base_ = -1; + clear_has_base(); +} +inline float LogParameter::base() const { + // @@protoc_insertion_point(field_get:caffe.LogParameter.base) + return base_; +} +inline void LogParameter::set_base(float value) { + set_has_base(); + base_ = value; + // @@protoc_insertion_point(field_set:caffe.LogParameter.base) +} + +// optional float scale = 2 [default = 1]; +inline bool LogParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LogParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +inline void LogParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LogParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float LogParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.LogParameter.scale) + return scale_; +} +inline void LogParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.LogParameter.scale) +} + +// optional float shift = 3 [default = 0]; +inline bool LogParameter::has_shift() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LogParameter::set_has_shift() { + _has_bits_[0] |= 0x00000004u; +} +inline void LogParameter::clear_has_shift() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LogParameter::clear_shift() { + shift_ = 0; + clear_has_shift(); +} +inline float LogParameter::shift() const { + // @@protoc_insertion_point(field_get:caffe.LogParameter.shift) + return shift_; +} +inline void LogParameter::set_shift(float value) { + set_has_shift(); + shift_ = value; + // @@protoc_insertion_point(field_set:caffe.LogParameter.shift) +} + +inline const LogParameter* LogParameter::internal_default_instance() { + return &LogParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// LRNParameter + +// optional uint32 local_size = 1 [default = 5]; +inline bool LRNParameter::has_local_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LRNParameter::set_has_local_size() { + _has_bits_[0] |= 0x00000001u; +} +inline void LRNParameter::clear_has_local_size() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LRNParameter::clear_local_size() { + local_size_ = 5u; + clear_has_local_size(); +} +inline ::google::protobuf::uint32 LRNParameter::local_size() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.local_size) + return local_size_; +} +inline void LRNParameter::set_local_size(::google::protobuf::uint32 value) { + set_has_local_size(); + local_size_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.local_size) +} + +// optional float alpha = 2 [default = 1]; +inline bool LRNParameter::has_alpha() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LRNParameter::set_has_alpha() { + _has_bits_[0] |= 0x00000002u; +} +inline void LRNParameter::clear_has_alpha() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LRNParameter::clear_alpha() { + alpha_ = 1; + clear_has_alpha(); +} +inline float LRNParameter::alpha() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.alpha) + return alpha_; +} +inline void LRNParameter::set_alpha(float value) { + set_has_alpha(); + alpha_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.alpha) +} + +// optional float beta = 3 [default = 0.75]; +inline bool LRNParameter::has_beta() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LRNParameter::set_has_beta() { + _has_bits_[0] |= 0x00000004u; +} +inline void LRNParameter::clear_has_beta() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LRNParameter::clear_beta() { + beta_ = 0.75f; + clear_has_beta(); +} +inline float LRNParameter::beta() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.beta) + return beta_; +} +inline void LRNParameter::set_beta(float value) { + set_has_beta(); + beta_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.beta) +} + +// optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; +inline bool LRNParameter::has_norm_region() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void LRNParameter::set_has_norm_region() { + _has_bits_[0] |= 0x00000008u; +} +inline void LRNParameter::clear_has_norm_region() { + _has_bits_[0] &= ~0x00000008u; +} +inline void LRNParameter::clear_norm_region() { + norm_region_ = 0; + clear_has_norm_region(); +} +inline ::caffe::LRNParameter_NormRegion LRNParameter::norm_region() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.norm_region) + return static_cast< ::caffe::LRNParameter_NormRegion >(norm_region_); +} +inline void LRNParameter::set_norm_region(::caffe::LRNParameter_NormRegion value) { + assert(::caffe::LRNParameter_NormRegion_IsValid(value)); + set_has_norm_region(); + norm_region_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.norm_region) +} + +// optional float k = 5 [default = 1]; +inline bool LRNParameter::has_k() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LRNParameter::set_has_k() { + _has_bits_[0] |= 0x00000010u; +} +inline void LRNParameter::clear_has_k() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LRNParameter::clear_k() { + k_ = 1; + clear_has_k(); +} +inline float LRNParameter::k() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.k) + return k_; +} +inline void LRNParameter::set_k(float value) { + set_has_k(); + k_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.k) +} + +// optional .caffe.LRNParameter.Engine engine = 6 [default = DEFAULT]; +inline bool LRNParameter::has_engine() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LRNParameter::set_has_engine() { + _has_bits_[0] |= 0x00000020u; +} +inline void LRNParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LRNParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::LRNParameter_Engine LRNParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.LRNParameter.engine) + return static_cast< ::caffe::LRNParameter_Engine >(engine_); +} +inline void LRNParameter::set_engine(::caffe::LRNParameter_Engine value) { + assert(::caffe::LRNParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.LRNParameter.engine) +} + +inline const LRNParameter* LRNParameter::internal_default_instance() { + return &LRNParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// MemoryDataParameter + +// optional uint32 batch_size = 1; +inline bool MemoryDataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void MemoryDataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000001u; +} +inline void MemoryDataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000001u; +} +inline void MemoryDataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +inline ::google::protobuf::uint32 MemoryDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.batch_size) + return batch_size_; +} +inline void MemoryDataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.batch_size) +} + +// optional uint32 channels = 2; +inline bool MemoryDataParameter::has_channels() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void MemoryDataParameter::set_has_channels() { + _has_bits_[0] |= 0x00000002u; +} +inline void MemoryDataParameter::clear_has_channels() { + _has_bits_[0] &= ~0x00000002u; +} +inline void MemoryDataParameter::clear_channels() { + channels_ = 0u; + clear_has_channels(); +} +inline ::google::protobuf::uint32 MemoryDataParameter::channels() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.channels) + return channels_; +} +inline void MemoryDataParameter::set_channels(::google::protobuf::uint32 value) { + set_has_channels(); + channels_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.channels) +} + +// optional uint32 height = 3; +inline bool MemoryDataParameter::has_height() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void MemoryDataParameter::set_has_height() { + _has_bits_[0] |= 0x00000004u; +} +inline void MemoryDataParameter::clear_has_height() { + _has_bits_[0] &= ~0x00000004u; +} +inline void MemoryDataParameter::clear_height() { + height_ = 0u; + clear_has_height(); +} +inline ::google::protobuf::uint32 MemoryDataParameter::height() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.height) + return height_; +} +inline void MemoryDataParameter::set_height(::google::protobuf::uint32 value) { + set_has_height(); + height_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.height) +} + +// optional uint32 width = 4; +inline bool MemoryDataParameter::has_width() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void MemoryDataParameter::set_has_width() { + _has_bits_[0] |= 0x00000008u; +} +inline void MemoryDataParameter::clear_has_width() { + _has_bits_[0] &= ~0x00000008u; +} +inline void MemoryDataParameter::clear_width() { + width_ = 0u; + clear_has_width(); +} +inline ::google::protobuf::uint32 MemoryDataParameter::width() const { + // @@protoc_insertion_point(field_get:caffe.MemoryDataParameter.width) + return width_; +} +inline void MemoryDataParameter::set_width(::google::protobuf::uint32 value) { + set_has_width(); + width_ = value; + // @@protoc_insertion_point(field_set:caffe.MemoryDataParameter.width) +} + +inline const MemoryDataParameter* MemoryDataParameter::internal_default_instance() { + return &MemoryDataParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// MVNParameter + +// optional bool normalize_variance = 1 [default = true]; +inline bool MVNParameter::has_normalize_variance() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void MVNParameter::set_has_normalize_variance() { + _has_bits_[0] |= 0x00000001u; +} +inline void MVNParameter::clear_has_normalize_variance() { + _has_bits_[0] &= ~0x00000001u; +} +inline void MVNParameter::clear_normalize_variance() { + normalize_variance_ = true; + clear_has_normalize_variance(); +} +inline bool MVNParameter::normalize_variance() const { + // @@protoc_insertion_point(field_get:caffe.MVNParameter.normalize_variance) + return normalize_variance_; +} +inline void MVNParameter::set_normalize_variance(bool value) { + set_has_normalize_variance(); + normalize_variance_ = value; + // @@protoc_insertion_point(field_set:caffe.MVNParameter.normalize_variance) +} + +// optional bool across_channels = 2 [default = false]; +inline bool MVNParameter::has_across_channels() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void MVNParameter::set_has_across_channels() { + _has_bits_[0] |= 0x00000002u; +} +inline void MVNParameter::clear_has_across_channels() { + _has_bits_[0] &= ~0x00000002u; +} +inline void MVNParameter::clear_across_channels() { + across_channels_ = false; + clear_has_across_channels(); +} +inline bool MVNParameter::across_channels() const { + // @@protoc_insertion_point(field_get:caffe.MVNParameter.across_channels) + return across_channels_; +} +inline void MVNParameter::set_across_channels(bool value) { + set_has_across_channels(); + across_channels_ = value; + // @@protoc_insertion_point(field_set:caffe.MVNParameter.across_channels) +} + +// optional float eps = 3 [default = 1e-09]; +inline bool MVNParameter::has_eps() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void MVNParameter::set_has_eps() { + _has_bits_[0] |= 0x00000004u; +} +inline void MVNParameter::clear_has_eps() { + _has_bits_[0] &= ~0x00000004u; +} +inline void MVNParameter::clear_eps() { + eps_ = 1e-09f; + clear_has_eps(); +} +inline float MVNParameter::eps() const { + // @@protoc_insertion_point(field_get:caffe.MVNParameter.eps) + return eps_; +} +inline void MVNParameter::set_eps(float value) { + set_has_eps(); + eps_ = value; + // @@protoc_insertion_point(field_set:caffe.MVNParameter.eps) +} + +inline const MVNParameter* MVNParameter::internal_default_instance() { + return &MVNParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ParameterParameter + +// optional .caffe.BlobShape shape = 1; +inline bool ParameterParameter::has_shape() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ParameterParameter::set_has_shape() { + _has_bits_[0] |= 0x00000001u; +} +inline void ParameterParameter::clear_has_shape() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ParameterParameter::clear_shape() { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + clear_has_shape(); +} +inline const ::caffe::BlobShape& ParameterParameter::shape() const { + // @@protoc_insertion_point(field_get:caffe.ParameterParameter.shape) + return shape_ != NULL ? *shape_ + : *::caffe::BlobShape::internal_default_instance(); +} +inline ::caffe::BlobShape* ParameterParameter::mutable_shape() { + set_has_shape(); + if (shape_ == NULL) { + shape_ = new ::caffe::BlobShape; + } + // @@protoc_insertion_point(field_mutable:caffe.ParameterParameter.shape) + return shape_; +} +inline ::caffe::BlobShape* ParameterParameter::release_shape() { + // @@protoc_insertion_point(field_release:caffe.ParameterParameter.shape) + clear_has_shape(); + ::caffe::BlobShape* temp = shape_; + shape_ = NULL; + return temp; +} +inline void ParameterParameter::set_allocated_shape(::caffe::BlobShape* shape) { + delete shape_; + shape_ = shape; + if (shape) { + set_has_shape(); + } else { + clear_has_shape(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ParameterParameter.shape) +} + +inline const ParameterParameter* ParameterParameter::internal_default_instance() { + return &ParameterParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// PoolingParameter + +// optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX]; +inline bool PoolingParameter::has_pool() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PoolingParameter::set_has_pool() { + _has_bits_[0] |= 0x00000001u; +} +inline void PoolingParameter::clear_has_pool() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PoolingParameter::clear_pool() { + pool_ = 0; + clear_has_pool(); +} +inline ::caffe::PoolingParameter_PoolMethod PoolingParameter::pool() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pool) + return static_cast< ::caffe::PoolingParameter_PoolMethod >(pool_); +} +inline void PoolingParameter::set_pool(::caffe::PoolingParameter_PoolMethod value) { + assert(::caffe::PoolingParameter_PoolMethod_IsValid(value)); + set_has_pool(); + pool_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pool) +} + +// optional uint32 pad = 4 [default = 0]; +inline bool PoolingParameter::has_pad() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PoolingParameter::set_has_pad() { + _has_bits_[0] |= 0x00000002u; +} +inline void PoolingParameter::clear_has_pad() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PoolingParameter::clear_pad() { + pad_ = 0u; + clear_has_pad(); +} +inline ::google::protobuf::uint32 PoolingParameter::pad() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad) + return pad_; +} +inline void PoolingParameter::set_pad(::google::protobuf::uint32 value) { + set_has_pad(); + pad_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad) +} + +// optional uint32 pad_h = 9 [default = 0]; +inline bool PoolingParameter::has_pad_h() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PoolingParameter::set_has_pad_h() { + _has_bits_[0] |= 0x00000004u; +} +inline void PoolingParameter::clear_has_pad_h() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PoolingParameter::clear_pad_h() { + pad_h_ = 0u; + clear_has_pad_h(); +} +inline ::google::protobuf::uint32 PoolingParameter::pad_h() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad_h) + return pad_h_; +} +inline void PoolingParameter::set_pad_h(::google::protobuf::uint32 value) { + set_has_pad_h(); + pad_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad_h) +} + +// optional uint32 pad_w = 10 [default = 0]; +inline bool PoolingParameter::has_pad_w() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void PoolingParameter::set_has_pad_w() { + _has_bits_[0] |= 0x00000008u; +} +inline void PoolingParameter::clear_has_pad_w() { + _has_bits_[0] &= ~0x00000008u; +} +inline void PoolingParameter::clear_pad_w() { + pad_w_ = 0u; + clear_has_pad_w(); +} +inline ::google::protobuf::uint32 PoolingParameter::pad_w() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.pad_w) + return pad_w_; +} +inline void PoolingParameter::set_pad_w(::google::protobuf::uint32 value) { + set_has_pad_w(); + pad_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.pad_w) +} + +// optional uint32 kernel_size = 2; +inline bool PoolingParameter::has_kernel_size() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void PoolingParameter::set_has_kernel_size() { + _has_bits_[0] |= 0x00000010u; +} +inline void PoolingParameter::clear_has_kernel_size() { + _has_bits_[0] &= ~0x00000010u; +} +inline void PoolingParameter::clear_kernel_size() { + kernel_size_ = 0u; + clear_has_kernel_size(); +} +inline ::google::protobuf::uint32 PoolingParameter::kernel_size() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_size) + return kernel_size_; +} +inline void PoolingParameter::set_kernel_size(::google::protobuf::uint32 value) { + set_has_kernel_size(); + kernel_size_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_size) +} + +// optional uint32 kernel_h = 5; +inline bool PoolingParameter::has_kernel_h() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void PoolingParameter::set_has_kernel_h() { + _has_bits_[0] |= 0x00000020u; +} +inline void PoolingParameter::clear_has_kernel_h() { + _has_bits_[0] &= ~0x00000020u; +} +inline void PoolingParameter::clear_kernel_h() { + kernel_h_ = 0u; + clear_has_kernel_h(); +} +inline ::google::protobuf::uint32 PoolingParameter::kernel_h() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_h) + return kernel_h_; +} +inline void PoolingParameter::set_kernel_h(::google::protobuf::uint32 value) { + set_has_kernel_h(); + kernel_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_h) +} + +// optional uint32 kernel_w = 6; +inline bool PoolingParameter::has_kernel_w() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void PoolingParameter::set_has_kernel_w() { + _has_bits_[0] |= 0x00000040u; +} +inline void PoolingParameter::clear_has_kernel_w() { + _has_bits_[0] &= ~0x00000040u; +} +inline void PoolingParameter::clear_kernel_w() { + kernel_w_ = 0u; + clear_has_kernel_w(); +} +inline ::google::protobuf::uint32 PoolingParameter::kernel_w() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.kernel_w) + return kernel_w_; +} +inline void PoolingParameter::set_kernel_w(::google::protobuf::uint32 value) { + set_has_kernel_w(); + kernel_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.kernel_w) +} + +// optional uint32 stride = 3 [default = 1]; +inline bool PoolingParameter::has_stride() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void PoolingParameter::set_has_stride() { + _has_bits_[0] |= 0x00000080u; +} +inline void PoolingParameter::clear_has_stride() { + _has_bits_[0] &= ~0x00000080u; +} +inline void PoolingParameter::clear_stride() { + stride_ = 1u; + clear_has_stride(); +} +inline ::google::protobuf::uint32 PoolingParameter::stride() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride) + return stride_; +} +inline void PoolingParameter::set_stride(::google::protobuf::uint32 value) { + set_has_stride(); + stride_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride) +} + +// optional uint32 stride_h = 7; +inline bool PoolingParameter::has_stride_h() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void PoolingParameter::set_has_stride_h() { + _has_bits_[0] |= 0x00000100u; +} +inline void PoolingParameter::clear_has_stride_h() { + _has_bits_[0] &= ~0x00000100u; +} +inline void PoolingParameter::clear_stride_h() { + stride_h_ = 0u; + clear_has_stride_h(); +} +inline ::google::protobuf::uint32 PoolingParameter::stride_h() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride_h) + return stride_h_; +} +inline void PoolingParameter::set_stride_h(::google::protobuf::uint32 value) { + set_has_stride_h(); + stride_h_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride_h) +} + +// optional uint32 stride_w = 8; +inline bool PoolingParameter::has_stride_w() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void PoolingParameter::set_has_stride_w() { + _has_bits_[0] |= 0x00000200u; +} +inline void PoolingParameter::clear_has_stride_w() { + _has_bits_[0] &= ~0x00000200u; +} +inline void PoolingParameter::clear_stride_w() { + stride_w_ = 0u; + clear_has_stride_w(); +} +inline ::google::protobuf::uint32 PoolingParameter::stride_w() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.stride_w) + return stride_w_; +} +inline void PoolingParameter::set_stride_w(::google::protobuf::uint32 value) { + set_has_stride_w(); + stride_w_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.stride_w) +} + +// optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT]; +inline bool PoolingParameter::has_engine() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void PoolingParameter::set_has_engine() { + _has_bits_[0] |= 0x00000400u; +} +inline void PoolingParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000400u; +} +inline void PoolingParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::PoolingParameter_Engine PoolingParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.engine) + return static_cast< ::caffe::PoolingParameter_Engine >(engine_); +} +inline void PoolingParameter::set_engine(::caffe::PoolingParameter_Engine value) { + assert(::caffe::PoolingParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.engine) +} + +// optional bool global_pooling = 12 [default = false]; +inline bool PoolingParameter::has_global_pooling() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void PoolingParameter::set_has_global_pooling() { + _has_bits_[0] |= 0x00000800u; +} +inline void PoolingParameter::clear_has_global_pooling() { + _has_bits_[0] &= ~0x00000800u; +} +inline void PoolingParameter::clear_global_pooling() { + global_pooling_ = false; + clear_has_global_pooling(); +} +inline bool PoolingParameter::global_pooling() const { + // @@protoc_insertion_point(field_get:caffe.PoolingParameter.global_pooling) + return global_pooling_; +} +inline void PoolingParameter::set_global_pooling(bool value) { + set_has_global_pooling(); + global_pooling_ = value; + // @@protoc_insertion_point(field_set:caffe.PoolingParameter.global_pooling) +} + +inline const PoolingParameter* PoolingParameter::internal_default_instance() { + return &PoolingParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// PowerParameter + +// optional float power = 1 [default = 1]; +inline bool PowerParameter::has_power() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PowerParameter::set_has_power() { + _has_bits_[0] |= 0x00000001u; +} +inline void PowerParameter::clear_has_power() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PowerParameter::clear_power() { + power_ = 1; + clear_has_power(); +} +inline float PowerParameter::power() const { + // @@protoc_insertion_point(field_get:caffe.PowerParameter.power) + return power_; +} +inline void PowerParameter::set_power(float value) { + set_has_power(); + power_ = value; + // @@protoc_insertion_point(field_set:caffe.PowerParameter.power) +} + +// optional float scale = 2 [default = 1]; +inline bool PowerParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PowerParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +inline void PowerParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PowerParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float PowerParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.PowerParameter.scale) + return scale_; +} +inline void PowerParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.PowerParameter.scale) +} + +// optional float shift = 3 [default = 0]; +inline bool PowerParameter::has_shift() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PowerParameter::set_has_shift() { + _has_bits_[0] |= 0x00000004u; +} +inline void PowerParameter::clear_has_shift() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PowerParameter::clear_shift() { + shift_ = 0; + clear_has_shift(); +} +inline float PowerParameter::shift() const { + // @@protoc_insertion_point(field_get:caffe.PowerParameter.shift) + return shift_; +} +inline void PowerParameter::set_shift(float value) { + set_has_shift(); + shift_ = value; + // @@protoc_insertion_point(field_set:caffe.PowerParameter.shift) +} + +inline const PowerParameter* PowerParameter::internal_default_instance() { + return &PowerParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// PythonParameter + +// optional string module = 1; +inline bool PythonParameter::has_module() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PythonParameter::set_has_module() { + _has_bits_[0] |= 0x00000001u; +} +inline void PythonParameter::clear_has_module() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PythonParameter::clear_module() { + module_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_module(); +} +inline const ::std::string& PythonParameter::module() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.module) + return module_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void PythonParameter::set_module(const ::std::string& value) { + set_has_module(); + module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.PythonParameter.module) +} +inline void PythonParameter::set_module(const char* value) { + set_has_module(); + module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.PythonParameter.module) +} +inline void PythonParameter::set_module(const char* value, size_t size) { + set_has_module(); + module_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.PythonParameter.module) +} +inline ::std::string* PythonParameter::mutable_module() { + set_has_module(); + // @@protoc_insertion_point(field_mutable:caffe.PythonParameter.module) + return module_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* PythonParameter::release_module() { + // @@protoc_insertion_point(field_release:caffe.PythonParameter.module) + clear_has_module(); + return module_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void PythonParameter::set_allocated_module(::std::string* module) { + if (module != NULL) { + set_has_module(); + } else { + clear_has_module(); + } + module_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), module); + // @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.module) +} + +// optional string layer = 2; +inline bool PythonParameter::has_layer() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PythonParameter::set_has_layer() { + _has_bits_[0] |= 0x00000002u; +} +inline void PythonParameter::clear_has_layer() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PythonParameter::clear_layer() { + layer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_layer(); +} +inline const ::std::string& PythonParameter::layer() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.layer) + return layer_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void PythonParameter::set_layer(const ::std::string& value) { + set_has_layer(); + layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.PythonParameter.layer) +} +inline void PythonParameter::set_layer(const char* value) { + set_has_layer(); + layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.PythonParameter.layer) +} +inline void PythonParameter::set_layer(const char* value, size_t size) { + set_has_layer(); + layer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.PythonParameter.layer) +} +inline ::std::string* PythonParameter::mutable_layer() { + set_has_layer(); + // @@protoc_insertion_point(field_mutable:caffe.PythonParameter.layer) + return layer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* PythonParameter::release_layer() { + // @@protoc_insertion_point(field_release:caffe.PythonParameter.layer) + clear_has_layer(); + return layer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void PythonParameter::set_allocated_layer(::std::string* layer) { + if (layer != NULL) { + set_has_layer(); + } else { + clear_has_layer(); + } + layer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), layer); + // @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.layer) +} + +// optional string param_str = 3 [default = ""]; +inline bool PythonParameter::has_param_str() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PythonParameter::set_has_param_str() { + _has_bits_[0] |= 0x00000004u; +} +inline void PythonParameter::clear_has_param_str() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PythonParameter::clear_param_str() { + param_str_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_param_str(); +} +inline const ::std::string& PythonParameter::param_str() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.param_str) + return param_str_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void PythonParameter::set_param_str(const ::std::string& value) { + set_has_param_str(); + param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.PythonParameter.param_str) +} +inline void PythonParameter::set_param_str(const char* value) { + set_has_param_str(); + param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.PythonParameter.param_str) +} +inline void PythonParameter::set_param_str(const char* value, size_t size) { + set_has_param_str(); + param_str_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.PythonParameter.param_str) +} +inline ::std::string* PythonParameter::mutable_param_str() { + set_has_param_str(); + // @@protoc_insertion_point(field_mutable:caffe.PythonParameter.param_str) + return param_str_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* PythonParameter::release_param_str() { + // @@protoc_insertion_point(field_release:caffe.PythonParameter.param_str) + clear_has_param_str(); + return param_str_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void PythonParameter::set_allocated_param_str(::std::string* param_str) { + if (param_str != NULL) { + set_has_param_str(); + } else { + clear_has_param_str(); + } + param_str_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), param_str); + // @@protoc_insertion_point(field_set_allocated:caffe.PythonParameter.param_str) +} + +// optional bool share_in_parallel = 4 [default = false]; +inline bool PythonParameter::has_share_in_parallel() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void PythonParameter::set_has_share_in_parallel() { + _has_bits_[0] |= 0x00000008u; +} +inline void PythonParameter::clear_has_share_in_parallel() { + _has_bits_[0] &= ~0x00000008u; +} +inline void PythonParameter::clear_share_in_parallel() { + share_in_parallel_ = false; + clear_has_share_in_parallel(); +} +inline bool PythonParameter::share_in_parallel() const { + // @@protoc_insertion_point(field_get:caffe.PythonParameter.share_in_parallel) + return share_in_parallel_; +} +inline void PythonParameter::set_share_in_parallel(bool value) { + set_has_share_in_parallel(); + share_in_parallel_ = value; + // @@protoc_insertion_point(field_set:caffe.PythonParameter.share_in_parallel) +} + +inline const PythonParameter* PythonParameter::internal_default_instance() { + return &PythonParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// RecurrentParameter + +// optional uint32 num_output = 1 [default = 0]; +inline bool RecurrentParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RecurrentParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000001u; +} +inline void RecurrentParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RecurrentParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +inline ::google::protobuf::uint32 RecurrentParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.num_output) + return num_output_; +} +inline void RecurrentParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.RecurrentParameter.num_output) +} + +// optional .caffe.FillerParameter weight_filler = 2; +inline bool RecurrentParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RecurrentParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000002u; +} +inline void RecurrentParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RecurrentParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +inline const ::caffe::FillerParameter& RecurrentParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* RecurrentParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.RecurrentParameter.weight_filler) + return weight_filler_; +} +inline ::caffe::FillerParameter* RecurrentParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.RecurrentParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +inline void RecurrentParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.RecurrentParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 3; +inline bool RecurrentParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RecurrentParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000004u; +} +inline void RecurrentParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RecurrentParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +inline const ::caffe::FillerParameter& RecurrentParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* RecurrentParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.RecurrentParameter.bias_filler) + return bias_filler_; +} +inline ::caffe::FillerParameter* RecurrentParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.RecurrentParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +inline void RecurrentParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.RecurrentParameter.bias_filler) +} + +// optional bool debug_info = 4 [default = false]; +inline bool RecurrentParameter::has_debug_info() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RecurrentParameter::set_has_debug_info() { + _has_bits_[0] |= 0x00000008u; +} +inline void RecurrentParameter::clear_has_debug_info() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RecurrentParameter::clear_debug_info() { + debug_info_ = false; + clear_has_debug_info(); +} +inline bool RecurrentParameter::debug_info() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.debug_info) + return debug_info_; +} +inline void RecurrentParameter::set_debug_info(bool value) { + set_has_debug_info(); + debug_info_ = value; + // @@protoc_insertion_point(field_set:caffe.RecurrentParameter.debug_info) +} + +// optional bool expose_hidden = 5 [default = false]; +inline bool RecurrentParameter::has_expose_hidden() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void RecurrentParameter::set_has_expose_hidden() { + _has_bits_[0] |= 0x00000010u; +} +inline void RecurrentParameter::clear_has_expose_hidden() { + _has_bits_[0] &= ~0x00000010u; +} +inline void RecurrentParameter::clear_expose_hidden() { + expose_hidden_ = false; + clear_has_expose_hidden(); +} +inline bool RecurrentParameter::expose_hidden() const { + // @@protoc_insertion_point(field_get:caffe.RecurrentParameter.expose_hidden) + return expose_hidden_; +} +inline void RecurrentParameter::set_expose_hidden(bool value) { + set_has_expose_hidden(); + expose_hidden_ = value; + // @@protoc_insertion_point(field_set:caffe.RecurrentParameter.expose_hidden) +} + +inline const RecurrentParameter* RecurrentParameter::internal_default_instance() { + return &RecurrentParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ReductionParameter + +// optional .caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM]; +inline bool ReductionParameter::has_operation() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ReductionParameter::set_has_operation() { + _has_bits_[0] |= 0x00000001u; +} +inline void ReductionParameter::clear_has_operation() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ReductionParameter::clear_operation() { + operation_ = 1; + clear_has_operation(); +} +inline ::caffe::ReductionParameter_ReductionOp ReductionParameter::operation() const { + // @@protoc_insertion_point(field_get:caffe.ReductionParameter.operation) + return static_cast< ::caffe::ReductionParameter_ReductionOp >(operation_); +} +inline void ReductionParameter::set_operation(::caffe::ReductionParameter_ReductionOp value) { + assert(::caffe::ReductionParameter_ReductionOp_IsValid(value)); + set_has_operation(); + operation_ = value; + // @@protoc_insertion_point(field_set:caffe.ReductionParameter.operation) +} + +// optional int32 axis = 2 [default = 0]; +inline bool ReductionParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ReductionParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +inline void ReductionParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ReductionParameter::clear_axis() { + axis_ = 0; + clear_has_axis(); +} +inline ::google::protobuf::int32 ReductionParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ReductionParameter.axis) + return axis_; +} +inline void ReductionParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ReductionParameter.axis) +} + +// optional float coeff = 3 [default = 1]; +inline bool ReductionParameter::has_coeff() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ReductionParameter::set_has_coeff() { + _has_bits_[0] |= 0x00000004u; +} +inline void ReductionParameter::clear_has_coeff() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ReductionParameter::clear_coeff() { + coeff_ = 1; + clear_has_coeff(); +} +inline float ReductionParameter::coeff() const { + // @@protoc_insertion_point(field_get:caffe.ReductionParameter.coeff) + return coeff_; +} +inline void ReductionParameter::set_coeff(float value) { + set_has_coeff(); + coeff_ = value; + // @@protoc_insertion_point(field_set:caffe.ReductionParameter.coeff) +} + +inline const ReductionParameter* ReductionParameter::internal_default_instance() { + return &ReductionParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ReLUParameter + +// optional float negative_slope = 1 [default = 0]; +inline bool ReLUParameter::has_negative_slope() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ReLUParameter::set_has_negative_slope() { + _has_bits_[0] |= 0x00000001u; +} +inline void ReLUParameter::clear_has_negative_slope() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ReLUParameter::clear_negative_slope() { + negative_slope_ = 0; + clear_has_negative_slope(); +} +inline float ReLUParameter::negative_slope() const { + // @@protoc_insertion_point(field_get:caffe.ReLUParameter.negative_slope) + return negative_slope_; +} +inline void ReLUParameter::set_negative_slope(float value) { + set_has_negative_slope(); + negative_slope_ = value; + // @@protoc_insertion_point(field_set:caffe.ReLUParameter.negative_slope) +} + +// optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT]; +inline bool ReLUParameter::has_engine() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ReLUParameter::set_has_engine() { + _has_bits_[0] |= 0x00000002u; +} +inline void ReLUParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ReLUParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::ReLUParameter_Engine ReLUParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.ReLUParameter.engine) + return static_cast< ::caffe::ReLUParameter_Engine >(engine_); +} +inline void ReLUParameter::set_engine(::caffe::ReLUParameter_Engine value) { + assert(::caffe::ReLUParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.ReLUParameter.engine) +} + +inline const ReLUParameter* ReLUParameter::internal_default_instance() { + return &ReLUParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ReshapeParameter + +// optional .caffe.BlobShape shape = 1; +inline bool ReshapeParameter::has_shape() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ReshapeParameter::set_has_shape() { + _has_bits_[0] |= 0x00000001u; +} +inline void ReshapeParameter::clear_has_shape() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ReshapeParameter::clear_shape() { + if (shape_ != NULL) shape_->::caffe::BlobShape::Clear(); + clear_has_shape(); +} +inline const ::caffe::BlobShape& ReshapeParameter::shape() const { + // @@protoc_insertion_point(field_get:caffe.ReshapeParameter.shape) + return shape_ != NULL ? *shape_ + : *::caffe::BlobShape::internal_default_instance(); +} +inline ::caffe::BlobShape* ReshapeParameter::mutable_shape() { + set_has_shape(); + if (shape_ == NULL) { + shape_ = new ::caffe::BlobShape; + } + // @@protoc_insertion_point(field_mutable:caffe.ReshapeParameter.shape) + return shape_; +} +inline ::caffe::BlobShape* ReshapeParameter::release_shape() { + // @@protoc_insertion_point(field_release:caffe.ReshapeParameter.shape) + clear_has_shape(); + ::caffe::BlobShape* temp = shape_; + shape_ = NULL; + return temp; +} +inline void ReshapeParameter::set_allocated_shape(::caffe::BlobShape* shape) { + delete shape_; + shape_ = shape; + if (shape) { + set_has_shape(); + } else { + clear_has_shape(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ReshapeParameter.shape) +} + +// optional int32 axis = 2 [default = 0]; +inline bool ReshapeParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ReshapeParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +inline void ReshapeParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ReshapeParameter::clear_axis() { + axis_ = 0; + clear_has_axis(); +} +inline ::google::protobuf::int32 ReshapeParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ReshapeParameter.axis) + return axis_; +} +inline void ReshapeParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ReshapeParameter.axis) +} + +// optional int32 num_axes = 3 [default = -1]; +inline bool ReshapeParameter::has_num_axes() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ReshapeParameter::set_has_num_axes() { + _has_bits_[0] |= 0x00000004u; +} +inline void ReshapeParameter::clear_has_num_axes() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ReshapeParameter::clear_num_axes() { + num_axes_ = -1; + clear_has_num_axes(); +} +inline ::google::protobuf::int32 ReshapeParameter::num_axes() const { + // @@protoc_insertion_point(field_get:caffe.ReshapeParameter.num_axes) + return num_axes_; +} +inline void ReshapeParameter::set_num_axes(::google::protobuf::int32 value) { + set_has_num_axes(); + num_axes_ = value; + // @@protoc_insertion_point(field_set:caffe.ReshapeParameter.num_axes) +} + +inline const ReshapeParameter* ReshapeParameter::internal_default_instance() { + return &ReshapeParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ScaleParameter + +// optional int32 axis = 1 [default = 1]; +inline bool ScaleParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ScaleParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +inline void ScaleParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ScaleParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 ScaleParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.axis) + return axis_; +} +inline void ScaleParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.ScaleParameter.axis) +} + +// optional int32 num_axes = 2 [default = 1]; +inline bool ScaleParameter::has_num_axes() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ScaleParameter::set_has_num_axes() { + _has_bits_[0] |= 0x00000002u; +} +inline void ScaleParameter::clear_has_num_axes() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ScaleParameter::clear_num_axes() { + num_axes_ = 1; + clear_has_num_axes(); +} +inline ::google::protobuf::int32 ScaleParameter::num_axes() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.num_axes) + return num_axes_; +} +inline void ScaleParameter::set_num_axes(::google::protobuf::int32 value) { + set_has_num_axes(); + num_axes_ = value; + // @@protoc_insertion_point(field_set:caffe.ScaleParameter.num_axes) +} + +// optional .caffe.FillerParameter filler = 3; +inline bool ScaleParameter::has_filler() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ScaleParameter::set_has_filler() { + _has_bits_[0] |= 0x00000004u; +} +inline void ScaleParameter::clear_has_filler() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ScaleParameter::clear_filler() { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + clear_has_filler(); +} +inline const ::caffe::FillerParameter& ScaleParameter::filler() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.filler) + return filler_ != NULL ? *filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* ScaleParameter::mutable_filler() { + set_has_filler(); + if (filler_ == NULL) { + filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ScaleParameter.filler) + return filler_; +} +inline ::caffe::FillerParameter* ScaleParameter::release_filler() { + // @@protoc_insertion_point(field_release:caffe.ScaleParameter.filler) + clear_has_filler(); + ::caffe::FillerParameter* temp = filler_; + filler_ = NULL; + return temp; +} +inline void ScaleParameter::set_allocated_filler(::caffe::FillerParameter* filler) { + delete filler_; + filler_ = filler; + if (filler) { + set_has_filler(); + } else { + clear_has_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ScaleParameter.filler) +} + +// optional bool bias_term = 4 [default = false]; +inline bool ScaleParameter::has_bias_term() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ScaleParameter::set_has_bias_term() { + _has_bits_[0] |= 0x00000008u; +} +inline void ScaleParameter::clear_has_bias_term() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ScaleParameter::clear_bias_term() { + bias_term_ = false; + clear_has_bias_term(); +} +inline bool ScaleParameter::bias_term() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.bias_term) + return bias_term_; +} +inline void ScaleParameter::set_bias_term(bool value) { + set_has_bias_term(); + bias_term_ = value; + // @@protoc_insertion_point(field_set:caffe.ScaleParameter.bias_term) +} + +// optional .caffe.FillerParameter bias_filler = 5; +inline bool ScaleParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ScaleParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000010u; +} +inline void ScaleParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ScaleParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +inline const ::caffe::FillerParameter& ScaleParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.ScaleParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* ScaleParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.ScaleParameter.bias_filler) + return bias_filler_; +} +inline ::caffe::FillerParameter* ScaleParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.ScaleParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +inline void ScaleParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.ScaleParameter.bias_filler) +} + +inline const ScaleParameter* ScaleParameter::internal_default_instance() { + return &ScaleParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// SigmoidParameter + +// optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT]; +inline bool SigmoidParameter::has_engine() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SigmoidParameter::set_has_engine() { + _has_bits_[0] |= 0x00000001u; +} +inline void SigmoidParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SigmoidParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::SigmoidParameter_Engine SigmoidParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.SigmoidParameter.engine) + return static_cast< ::caffe::SigmoidParameter_Engine >(engine_); +} +inline void SigmoidParameter::set_engine(::caffe::SigmoidParameter_Engine value) { + assert(::caffe::SigmoidParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.SigmoidParameter.engine) +} + +inline const SigmoidParameter* SigmoidParameter::internal_default_instance() { + return &SigmoidParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// SliceParameter + +// optional int32 axis = 3 [default = 1]; +inline bool SliceParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SliceParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +inline void SliceParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SliceParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 SliceParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.SliceParameter.axis) + return axis_; +} +inline void SliceParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.SliceParameter.axis) +} + +// repeated uint32 slice_point = 2; +inline int SliceParameter::slice_point_size() const { + return slice_point_.size(); +} +inline void SliceParameter::clear_slice_point() { + slice_point_.Clear(); +} +inline ::google::protobuf::uint32 SliceParameter::slice_point(int index) const { + // @@protoc_insertion_point(field_get:caffe.SliceParameter.slice_point) + return slice_point_.Get(index); +} +inline void SliceParameter::set_slice_point(int index, ::google::protobuf::uint32 value) { + slice_point_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.SliceParameter.slice_point) +} +inline void SliceParameter::add_slice_point(::google::protobuf::uint32 value) { + slice_point_.Add(value); + // @@protoc_insertion_point(field_add:caffe.SliceParameter.slice_point) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +SliceParameter::slice_point() const { + // @@protoc_insertion_point(field_list:caffe.SliceParameter.slice_point) + return slice_point_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +SliceParameter::mutable_slice_point() { + // @@protoc_insertion_point(field_mutable_list:caffe.SliceParameter.slice_point) + return &slice_point_; +} + +// optional uint32 slice_dim = 1 [default = 1]; +inline bool SliceParameter::has_slice_dim() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SliceParameter::set_has_slice_dim() { + _has_bits_[0] |= 0x00000004u; +} +inline void SliceParameter::clear_has_slice_dim() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SliceParameter::clear_slice_dim() { + slice_dim_ = 1u; + clear_has_slice_dim(); +} +inline ::google::protobuf::uint32 SliceParameter::slice_dim() const { + // @@protoc_insertion_point(field_get:caffe.SliceParameter.slice_dim) + return slice_dim_; +} +inline void SliceParameter::set_slice_dim(::google::protobuf::uint32 value) { + set_has_slice_dim(); + slice_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.SliceParameter.slice_dim) +} + +inline const SliceParameter* SliceParameter::internal_default_instance() { + return &SliceParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// SoftmaxParameter + +// optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT]; +inline bool SoftmaxParameter::has_engine() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SoftmaxParameter::set_has_engine() { + _has_bits_[0] |= 0x00000001u; +} +inline void SoftmaxParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SoftmaxParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::SoftmaxParameter_Engine SoftmaxParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.SoftmaxParameter.engine) + return static_cast< ::caffe::SoftmaxParameter_Engine >(engine_); +} +inline void SoftmaxParameter::set_engine(::caffe::SoftmaxParameter_Engine value) { + assert(::caffe::SoftmaxParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.SoftmaxParameter.engine) +} + +// optional int32 axis = 2 [default = 1]; +inline bool SoftmaxParameter::has_axis() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SoftmaxParameter::set_has_axis() { + _has_bits_[0] |= 0x00000002u; +} +inline void SoftmaxParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SoftmaxParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 SoftmaxParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.SoftmaxParameter.axis) + return axis_; +} +inline void SoftmaxParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.SoftmaxParameter.axis) +} + +inline const SoftmaxParameter* SoftmaxParameter::internal_default_instance() { + return &SoftmaxParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// TanHParameter + +// optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT]; +inline bool TanHParameter::has_engine() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void TanHParameter::set_has_engine() { + _has_bits_[0] |= 0x00000001u; +} +inline void TanHParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000001u; +} +inline void TanHParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::TanHParameter_Engine TanHParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.TanHParameter.engine) + return static_cast< ::caffe::TanHParameter_Engine >(engine_); +} +inline void TanHParameter::set_engine(::caffe::TanHParameter_Engine value) { + assert(::caffe::TanHParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.TanHParameter.engine) +} + +inline const TanHParameter* TanHParameter::internal_default_instance() { + return &TanHParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// TileParameter + +// optional int32 axis = 1 [default = 1]; +inline bool TileParameter::has_axis() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void TileParameter::set_has_axis() { + _has_bits_[0] |= 0x00000001u; +} +inline void TileParameter::clear_has_axis() { + _has_bits_[0] &= ~0x00000001u; +} +inline void TileParameter::clear_axis() { + axis_ = 1; + clear_has_axis(); +} +inline ::google::protobuf::int32 TileParameter::axis() const { + // @@protoc_insertion_point(field_get:caffe.TileParameter.axis) + return axis_; +} +inline void TileParameter::set_axis(::google::protobuf::int32 value) { + set_has_axis(); + axis_ = value; + // @@protoc_insertion_point(field_set:caffe.TileParameter.axis) +} + +// optional int32 tiles = 2; +inline bool TileParameter::has_tiles() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void TileParameter::set_has_tiles() { + _has_bits_[0] |= 0x00000002u; +} +inline void TileParameter::clear_has_tiles() { + _has_bits_[0] &= ~0x00000002u; +} +inline void TileParameter::clear_tiles() { + tiles_ = 0; + clear_has_tiles(); +} +inline ::google::protobuf::int32 TileParameter::tiles() const { + // @@protoc_insertion_point(field_get:caffe.TileParameter.tiles) + return tiles_; +} +inline void TileParameter::set_tiles(::google::protobuf::int32 value) { + set_has_tiles(); + tiles_ = value; + // @@protoc_insertion_point(field_set:caffe.TileParameter.tiles) +} + +inline const TileParameter* TileParameter::internal_default_instance() { + return &TileParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// ThresholdParameter + +// optional float threshold = 1 [default = 0]; +inline bool ThresholdParameter::has_threshold() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ThresholdParameter::set_has_threshold() { + _has_bits_[0] |= 0x00000001u; +} +inline void ThresholdParameter::clear_has_threshold() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ThresholdParameter::clear_threshold() { + threshold_ = 0; + clear_has_threshold(); +} +inline float ThresholdParameter::threshold() const { + // @@protoc_insertion_point(field_get:caffe.ThresholdParameter.threshold) + return threshold_; +} +inline void ThresholdParameter::set_threshold(float value) { + set_has_threshold(); + threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.ThresholdParameter.threshold) +} + +inline const ThresholdParameter* ThresholdParameter::internal_default_instance() { + return &ThresholdParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// WindowDataParameter + +// optional string source = 1; +inline bool WindowDataParameter::has_source() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void WindowDataParameter::set_has_source() { + _has_bits_[0] |= 0x00000001u; +} +inline void WindowDataParameter::clear_has_source() { + _has_bits_[0] &= ~0x00000001u; +} +inline void WindowDataParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +inline const ::std::string& WindowDataParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void WindowDataParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.source) +} +inline void WindowDataParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.source) +} +inline void WindowDataParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.source) +} +inline ::std::string* WindowDataParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* WindowDataParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void WindowDataParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.source) +} + +// optional float scale = 2 [default = 1]; +inline bool WindowDataParameter::has_scale() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void WindowDataParameter::set_has_scale() { + _has_bits_[0] |= 0x00000002u; +} +inline void WindowDataParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00000002u; +} +inline void WindowDataParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float WindowDataParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.scale) + return scale_; +} +inline void WindowDataParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.scale) +} + +// optional string mean_file = 3; +inline bool WindowDataParameter::has_mean_file() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void WindowDataParameter::set_has_mean_file() { + _has_bits_[0] |= 0x00000004u; +} +inline void WindowDataParameter::clear_has_mean_file() { + _has_bits_[0] &= ~0x00000004u; +} +inline void WindowDataParameter::clear_mean_file() { + mean_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_mean_file(); +} +inline const ::std::string& WindowDataParameter::mean_file() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.mean_file) + return mean_file_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void WindowDataParameter::set_mean_file(const ::std::string& value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.mean_file) +} +inline void WindowDataParameter::set_mean_file(const char* value) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.mean_file) +} +inline void WindowDataParameter::set_mean_file(const char* value, size_t size) { + set_has_mean_file(); + mean_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.mean_file) +} +inline ::std::string* WindowDataParameter::mutable_mean_file() { + set_has_mean_file(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.mean_file) + return mean_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* WindowDataParameter::release_mean_file() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.mean_file) + clear_has_mean_file(); + return mean_file_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void WindowDataParameter::set_allocated_mean_file(::std::string* mean_file) { + if (mean_file != NULL) { + set_has_mean_file(); + } else { + clear_has_mean_file(); + } + mean_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mean_file); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.mean_file) +} + +// optional uint32 batch_size = 4; +inline bool WindowDataParameter::has_batch_size() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void WindowDataParameter::set_has_batch_size() { + _has_bits_[0] |= 0x00000008u; +} +inline void WindowDataParameter::clear_has_batch_size() { + _has_bits_[0] &= ~0x00000008u; +} +inline void WindowDataParameter::clear_batch_size() { + batch_size_ = 0u; + clear_has_batch_size(); +} +inline ::google::protobuf::uint32 WindowDataParameter::batch_size() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.batch_size) + return batch_size_; +} +inline void WindowDataParameter::set_batch_size(::google::protobuf::uint32 value) { + set_has_batch_size(); + batch_size_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.batch_size) +} + +// optional uint32 crop_size = 5 [default = 0]; +inline bool WindowDataParameter::has_crop_size() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void WindowDataParameter::set_has_crop_size() { + _has_bits_[0] |= 0x00000010u; +} +inline void WindowDataParameter::clear_has_crop_size() { + _has_bits_[0] &= ~0x00000010u; +} +inline void WindowDataParameter::clear_crop_size() { + crop_size_ = 0u; + clear_has_crop_size(); +} +inline ::google::protobuf::uint32 WindowDataParameter::crop_size() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.crop_size) + return crop_size_; +} +inline void WindowDataParameter::set_crop_size(::google::protobuf::uint32 value) { + set_has_crop_size(); + crop_size_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.crop_size) +} + +// optional bool mirror = 6 [default = false]; +inline bool WindowDataParameter::has_mirror() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void WindowDataParameter::set_has_mirror() { + _has_bits_[0] |= 0x00000020u; +} +inline void WindowDataParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00000020u; +} +inline void WindowDataParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +inline bool WindowDataParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.mirror) + return mirror_; +} +inline void WindowDataParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.mirror) +} + +// optional float fg_threshold = 7 [default = 0.5]; +inline bool WindowDataParameter::has_fg_threshold() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void WindowDataParameter::set_has_fg_threshold() { + _has_bits_[0] |= 0x00000040u; +} +inline void WindowDataParameter::clear_has_fg_threshold() { + _has_bits_[0] &= ~0x00000040u; +} +inline void WindowDataParameter::clear_fg_threshold() { + fg_threshold_ = 0.5f; + clear_has_fg_threshold(); +} +inline float WindowDataParameter::fg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.fg_threshold) + return fg_threshold_; +} +inline void WindowDataParameter::set_fg_threshold(float value) { + set_has_fg_threshold(); + fg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.fg_threshold) +} + +// optional float bg_threshold = 8 [default = 0.5]; +inline bool WindowDataParameter::has_bg_threshold() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void WindowDataParameter::set_has_bg_threshold() { + _has_bits_[0] |= 0x00000080u; +} +inline void WindowDataParameter::clear_has_bg_threshold() { + _has_bits_[0] &= ~0x00000080u; +} +inline void WindowDataParameter::clear_bg_threshold() { + bg_threshold_ = 0.5f; + clear_has_bg_threshold(); +} +inline float WindowDataParameter::bg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.bg_threshold) + return bg_threshold_; +} +inline void WindowDataParameter::set_bg_threshold(float value) { + set_has_bg_threshold(); + bg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.bg_threshold) +} + +// optional float fg_fraction = 9 [default = 0.25]; +inline bool WindowDataParameter::has_fg_fraction() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void WindowDataParameter::set_has_fg_fraction() { + _has_bits_[0] |= 0x00000100u; +} +inline void WindowDataParameter::clear_has_fg_fraction() { + _has_bits_[0] &= ~0x00000100u; +} +inline void WindowDataParameter::clear_fg_fraction() { + fg_fraction_ = 0.25f; + clear_has_fg_fraction(); +} +inline float WindowDataParameter::fg_fraction() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.fg_fraction) + return fg_fraction_; +} +inline void WindowDataParameter::set_fg_fraction(float value) { + set_has_fg_fraction(); + fg_fraction_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.fg_fraction) +} + +// optional uint32 context_pad = 10 [default = 0]; +inline bool WindowDataParameter::has_context_pad() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void WindowDataParameter::set_has_context_pad() { + _has_bits_[0] |= 0x00000200u; +} +inline void WindowDataParameter::clear_has_context_pad() { + _has_bits_[0] &= ~0x00000200u; +} +inline void WindowDataParameter::clear_context_pad() { + context_pad_ = 0u; + clear_has_context_pad(); +} +inline ::google::protobuf::uint32 WindowDataParameter::context_pad() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.context_pad) + return context_pad_; +} +inline void WindowDataParameter::set_context_pad(::google::protobuf::uint32 value) { + set_has_context_pad(); + context_pad_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.context_pad) +} + +// optional string crop_mode = 11 [default = "warp"]; +inline bool WindowDataParameter::has_crop_mode() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void WindowDataParameter::set_has_crop_mode() { + _has_bits_[0] |= 0x00000400u; +} +inline void WindowDataParameter::clear_has_crop_mode() { + _has_bits_[0] &= ~0x00000400u; +} +inline void WindowDataParameter::clear_crop_mode() { + crop_mode_.ClearToDefaultNoArena(_default_crop_mode_); + clear_has_crop_mode(); +} +inline const ::std::string& WindowDataParameter::crop_mode() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.crop_mode) + return crop_mode_.GetNoArena(_default_crop_mode_); +} +inline void WindowDataParameter::set_crop_mode(const ::std::string& value) { + set_has_crop_mode(); + crop_mode_.SetNoArena(_default_crop_mode_, value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.crop_mode) +} +inline void WindowDataParameter::set_crop_mode(const char* value) { + set_has_crop_mode(); + crop_mode_.SetNoArena(_default_crop_mode_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.crop_mode) +} +inline void WindowDataParameter::set_crop_mode(const char* value, size_t size) { + set_has_crop_mode(); + crop_mode_.SetNoArena(_default_crop_mode_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.crop_mode) +} +inline ::std::string* WindowDataParameter::mutable_crop_mode() { + set_has_crop_mode(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.crop_mode) + return crop_mode_.MutableNoArena(_default_crop_mode_); +} +inline ::std::string* WindowDataParameter::release_crop_mode() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.crop_mode) + clear_has_crop_mode(); + return crop_mode_.ReleaseNoArena(_default_crop_mode_); +} +inline void WindowDataParameter::set_allocated_crop_mode(::std::string* crop_mode) { + if (crop_mode != NULL) { + set_has_crop_mode(); + } else { + clear_has_crop_mode(); + } + crop_mode_.SetAllocatedNoArena(_default_crop_mode_, crop_mode); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.crop_mode) +} + +// optional bool cache_images = 12 [default = false]; +inline bool WindowDataParameter::has_cache_images() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void WindowDataParameter::set_has_cache_images() { + _has_bits_[0] |= 0x00000800u; +} +inline void WindowDataParameter::clear_has_cache_images() { + _has_bits_[0] &= ~0x00000800u; +} +inline void WindowDataParameter::clear_cache_images() { + cache_images_ = false; + clear_has_cache_images(); +} +inline bool WindowDataParameter::cache_images() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.cache_images) + return cache_images_; +} +inline void WindowDataParameter::set_cache_images(bool value) { + set_has_cache_images(); + cache_images_ = value; + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.cache_images) +} + +// optional string root_folder = 13 [default = ""]; +inline bool WindowDataParameter::has_root_folder() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void WindowDataParameter::set_has_root_folder() { + _has_bits_[0] |= 0x00001000u; +} +inline void WindowDataParameter::clear_has_root_folder() { + _has_bits_[0] &= ~0x00001000u; +} +inline void WindowDataParameter::clear_root_folder() { + root_folder_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_root_folder(); +} +inline const ::std::string& WindowDataParameter::root_folder() const { + // @@protoc_insertion_point(field_get:caffe.WindowDataParameter.root_folder) + return root_folder_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void WindowDataParameter::set_root_folder(const ::std::string& value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.WindowDataParameter.root_folder) +} +inline void WindowDataParameter::set_root_folder(const char* value) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.WindowDataParameter.root_folder) +} +inline void WindowDataParameter::set_root_folder(const char* value, size_t size) { + set_has_root_folder(); + root_folder_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.WindowDataParameter.root_folder) +} +inline ::std::string* WindowDataParameter::mutable_root_folder() { + set_has_root_folder(); + // @@protoc_insertion_point(field_mutable:caffe.WindowDataParameter.root_folder) + return root_folder_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* WindowDataParameter::release_root_folder() { + // @@protoc_insertion_point(field_release:caffe.WindowDataParameter.root_folder) + clear_has_root_folder(); + return root_folder_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void WindowDataParameter::set_allocated_root_folder(::std::string* root_folder) { + if (root_folder != NULL) { + set_has_root_folder(); + } else { + clear_has_root_folder(); + } + root_folder_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root_folder); + // @@protoc_insertion_point(field_set_allocated:caffe.WindowDataParameter.root_folder) +} + +inline const WindowDataParameter* WindowDataParameter::internal_default_instance() { + return &WindowDataParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// SPPParameter + +// optional uint32 pyramid_height = 1; +inline bool SPPParameter::has_pyramid_height() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SPPParameter::set_has_pyramid_height() { + _has_bits_[0] |= 0x00000001u; +} +inline void SPPParameter::clear_has_pyramid_height() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SPPParameter::clear_pyramid_height() { + pyramid_height_ = 0u; + clear_has_pyramid_height(); +} +inline ::google::protobuf::uint32 SPPParameter::pyramid_height() const { + // @@protoc_insertion_point(field_get:caffe.SPPParameter.pyramid_height) + return pyramid_height_; +} +inline void SPPParameter::set_pyramid_height(::google::protobuf::uint32 value) { + set_has_pyramid_height(); + pyramid_height_ = value; + // @@protoc_insertion_point(field_set:caffe.SPPParameter.pyramid_height) +} + +// optional .caffe.SPPParameter.PoolMethod pool = 2 [default = MAX]; +inline bool SPPParameter::has_pool() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SPPParameter::set_has_pool() { + _has_bits_[0] |= 0x00000002u; +} +inline void SPPParameter::clear_has_pool() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SPPParameter::clear_pool() { + pool_ = 0; + clear_has_pool(); +} +inline ::caffe::SPPParameter_PoolMethod SPPParameter::pool() const { + // @@protoc_insertion_point(field_get:caffe.SPPParameter.pool) + return static_cast< ::caffe::SPPParameter_PoolMethod >(pool_); +} +inline void SPPParameter::set_pool(::caffe::SPPParameter_PoolMethod value) { + assert(::caffe::SPPParameter_PoolMethod_IsValid(value)); + set_has_pool(); + pool_ = value; + // @@protoc_insertion_point(field_set:caffe.SPPParameter.pool) +} + +// optional .caffe.SPPParameter.Engine engine = 6 [default = DEFAULT]; +inline bool SPPParameter::has_engine() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SPPParameter::set_has_engine() { + _has_bits_[0] |= 0x00000004u; +} +inline void SPPParameter::clear_has_engine() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SPPParameter::clear_engine() { + engine_ = 0; + clear_has_engine(); +} +inline ::caffe::SPPParameter_Engine SPPParameter::engine() const { + // @@protoc_insertion_point(field_get:caffe.SPPParameter.engine) + return static_cast< ::caffe::SPPParameter_Engine >(engine_); +} +inline void SPPParameter::set_engine(::caffe::SPPParameter_Engine value) { + assert(::caffe::SPPParameter_Engine_IsValid(value)); + set_has_engine(); + engine_ = value; + // @@protoc_insertion_point(field_set:caffe.SPPParameter.engine) +} + +inline const SPPParameter* SPPParameter::internal_default_instance() { + return &SPPParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// V1LayerParameter + +// repeated string bottom = 2; +inline int V1LayerParameter::bottom_size() const { + return bottom_.size(); +} +inline void V1LayerParameter::clear_bottom() { + bottom_.Clear(); +} +inline const ::std::string& V1LayerParameter::bottom(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.bottom) + return bottom_.Get(index); +} +inline ::std::string* V1LayerParameter::mutable_bottom(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.bottom) + return bottom_.Mutable(index); +} +inline void V1LayerParameter::set_bottom(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.bottom) + bottom_.Mutable(index)->assign(value); +} +inline void V1LayerParameter::set_bottom(int index, const char* value) { + bottom_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.bottom) +} +inline void V1LayerParameter::set_bottom(int index, const char* value, size_t size) { + bottom_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.bottom) +} +inline ::std::string* V1LayerParameter::add_bottom() { + // @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.bottom) + return bottom_.Add(); +} +inline void V1LayerParameter::add_bottom(const ::std::string& value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.bottom) +} +inline void V1LayerParameter::add_bottom(const char* value) { + bottom_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.bottom) +} +inline void V1LayerParameter::add_bottom(const char* value, size_t size) { + bottom_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.bottom) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +V1LayerParameter::bottom() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.bottom) + return bottom_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +V1LayerParameter::mutable_bottom() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.bottom) + return &bottom_; +} + +// repeated string top = 3; +inline int V1LayerParameter::top_size() const { + return top_.size(); +} +inline void V1LayerParameter::clear_top() { + top_.Clear(); +} +inline const ::std::string& V1LayerParameter::top(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.top) + return top_.Get(index); +} +inline ::std::string* V1LayerParameter::mutable_top(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.top) + return top_.Mutable(index); +} +inline void V1LayerParameter::set_top(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.top) + top_.Mutable(index)->assign(value); +} +inline void V1LayerParameter::set_top(int index, const char* value) { + top_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.top) +} +inline void V1LayerParameter::set_top(int index, const char* value, size_t size) { + top_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.top) +} +inline ::std::string* V1LayerParameter::add_top() { + // @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.top) + return top_.Add(); +} +inline void V1LayerParameter::add_top(const ::std::string& value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.top) +} +inline void V1LayerParameter::add_top(const char* value) { + top_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.top) +} +inline void V1LayerParameter::add_top(const char* value, size_t size) { + top_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.top) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +V1LayerParameter::top() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.top) + return top_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +V1LayerParameter::mutable_top() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.top) + return &top_; +} + +// optional string name = 4; +inline bool V1LayerParameter::has_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void V1LayerParameter::set_has_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void V1LayerParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void V1LayerParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +inline const ::std::string& V1LayerParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V1LayerParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.name) +} +inline void V1LayerParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.name) +} +inline void V1LayerParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.name) +} +inline ::std::string* V1LayerParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* V1LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V1LayerParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.name) +} + +// repeated .caffe.NetStateRule include = 32; +inline int V1LayerParameter::include_size() const { + return include_.size(); +} +inline void V1LayerParameter::clear_include() { + include_.Clear(); +} +inline const ::caffe::NetStateRule& V1LayerParameter::include(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.include) + return include_.Get(index); +} +inline ::caffe::NetStateRule* V1LayerParameter::mutable_include(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.include) + return include_.Mutable(index); +} +inline ::caffe::NetStateRule* V1LayerParameter::add_include() { + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.include) + return include_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +V1LayerParameter::mutable_include() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.include) + return &include_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +V1LayerParameter::include() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.include) + return include_; +} + +// repeated .caffe.NetStateRule exclude = 33; +inline int V1LayerParameter::exclude_size() const { + return exclude_.size(); +} +inline void V1LayerParameter::clear_exclude() { + exclude_.Clear(); +} +inline const ::caffe::NetStateRule& V1LayerParameter::exclude(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.exclude) + return exclude_.Get(index); +} +inline ::caffe::NetStateRule* V1LayerParameter::mutable_exclude(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.exclude) + return exclude_.Mutable(index); +} +inline ::caffe::NetStateRule* V1LayerParameter::add_exclude() { + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.exclude) + return exclude_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >* +V1LayerParameter::mutable_exclude() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.exclude) + return &exclude_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >& +V1LayerParameter::exclude() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.exclude) + return exclude_; +} + +// optional .caffe.V1LayerParameter.LayerType type = 5; +inline bool V1LayerParameter::has_type() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void V1LayerParameter::set_has_type() { + _has_bits_[0] |= 0x00000020u; +} +inline void V1LayerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000020u; +} +inline void V1LayerParameter::clear_type() { + type_ = 0; + clear_has_type(); +} +inline ::caffe::V1LayerParameter_LayerType V1LayerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.type) + return static_cast< ::caffe::V1LayerParameter_LayerType >(type_); +} +inline void V1LayerParameter::set_type(::caffe::V1LayerParameter_LayerType value) { + assert(::caffe::V1LayerParameter_LayerType_IsValid(value)); + set_has_type(); + type_ = value; + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.type) +} + +// repeated .caffe.BlobProto blobs = 6; +inline int V1LayerParameter::blobs_size() const { + return blobs_.size(); +} +inline void V1LayerParameter::clear_blobs() { + blobs_.Clear(); +} +inline const ::caffe::BlobProto& V1LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blobs) + return blobs_.Get(index); +} +inline ::caffe::BlobProto* V1LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.blobs) + return blobs_.Mutable(index); +} +inline ::caffe::BlobProto* V1LayerParameter::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blobs) + return blobs_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +V1LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blobs) + return &blobs_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +V1LayerParameter::blobs() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blobs) + return blobs_; +} + +// repeated string param = 1001; +inline int V1LayerParameter::param_size() const { + return param_.size(); +} +inline void V1LayerParameter::clear_param() { + param_.Clear(); +} +inline const ::std::string& V1LayerParameter::param(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.param) + return param_.Get(index); +} +inline ::std::string* V1LayerParameter::mutable_param(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.param) + return param_.Mutable(index); +} +inline void V1LayerParameter::set_param(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.param) + param_.Mutable(index)->assign(value); +} +inline void V1LayerParameter::set_param(int index, const char* value) { + param_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:caffe.V1LayerParameter.param) +} +inline void V1LayerParameter::set_param(int index, const char* value, size_t size) { + param_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:caffe.V1LayerParameter.param) +} +inline ::std::string* V1LayerParameter::add_param() { + // @@protoc_insertion_point(field_add_mutable:caffe.V1LayerParameter.param) + return param_.Add(); +} +inline void V1LayerParameter::add_param(const ::std::string& value) { + param_.Add()->assign(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.param) +} +inline void V1LayerParameter::add_param(const char* value) { + param_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:caffe.V1LayerParameter.param) +} +inline void V1LayerParameter::add_param(const char* value, size_t size) { + param_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:caffe.V1LayerParameter.param) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +V1LayerParameter::param() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.param) + return param_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +V1LayerParameter::mutable_param() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.param) + return ¶m_; +} + +// repeated .caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002; +inline int V1LayerParameter::blob_share_mode_size() const { + return blob_share_mode_.size(); +} +inline void V1LayerParameter::clear_blob_share_mode() { + blob_share_mode_.Clear(); +} +inline ::caffe::V1LayerParameter_DimCheckMode V1LayerParameter::blob_share_mode(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blob_share_mode) + return static_cast< ::caffe::V1LayerParameter_DimCheckMode >(blob_share_mode_.Get(index)); +} +inline void V1LayerParameter::set_blob_share_mode(int index, ::caffe::V1LayerParameter_DimCheckMode value) { + assert(::caffe::V1LayerParameter_DimCheckMode_IsValid(value)); + blob_share_mode_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.blob_share_mode) +} +inline void V1LayerParameter::add_blob_share_mode(::caffe::V1LayerParameter_DimCheckMode value) { + assert(::caffe::V1LayerParameter_DimCheckMode_IsValid(value)); + blob_share_mode_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blob_share_mode) +} +inline const ::google::protobuf::RepeatedField& +V1LayerParameter::blob_share_mode() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blob_share_mode) + return blob_share_mode_; +} +inline ::google::protobuf::RepeatedField* +V1LayerParameter::mutable_blob_share_mode() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blob_share_mode) + return &blob_share_mode_; +} + +// repeated float blobs_lr = 7; +inline int V1LayerParameter::blobs_lr_size() const { + return blobs_lr_.size(); +} +inline void V1LayerParameter::clear_blobs_lr() { + blobs_lr_.Clear(); +} +inline float V1LayerParameter::blobs_lr(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.blobs_lr) + return blobs_lr_.Get(index); +} +inline void V1LayerParameter::set_blobs_lr(int index, float value) { + blobs_lr_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.blobs_lr) +} +inline void V1LayerParameter::add_blobs_lr(float value) { + blobs_lr_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.blobs_lr) +} +inline const ::google::protobuf::RepeatedField< float >& +V1LayerParameter::blobs_lr() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.blobs_lr) + return blobs_lr_; +} +inline ::google::protobuf::RepeatedField< float >* +V1LayerParameter::mutable_blobs_lr() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.blobs_lr) + return &blobs_lr_; +} + +// repeated float weight_decay = 8; +inline int V1LayerParameter::weight_decay_size() const { + return weight_decay_.size(); +} +inline void V1LayerParameter::clear_weight_decay() { + weight_decay_.Clear(); +} +inline float V1LayerParameter::weight_decay(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.weight_decay) + return weight_decay_.Get(index); +} +inline void V1LayerParameter::set_weight_decay(int index, float value) { + weight_decay_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.weight_decay) +} +inline void V1LayerParameter::add_weight_decay(float value) { + weight_decay_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.weight_decay) +} +inline const ::google::protobuf::RepeatedField< float >& +V1LayerParameter::weight_decay() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.weight_decay) + return weight_decay_; +} +inline ::google::protobuf::RepeatedField< float >* +V1LayerParameter::mutable_weight_decay() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.weight_decay) + return &weight_decay_; +} + +// repeated float loss_weight = 35; +inline int V1LayerParameter::loss_weight_size() const { + return loss_weight_.size(); +} +inline void V1LayerParameter::clear_loss_weight() { + loss_weight_.Clear(); +} +inline float V1LayerParameter::loss_weight(int index) const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.loss_weight) + return loss_weight_.Get(index); +} +inline void V1LayerParameter::set_loss_weight(int index, float value) { + loss_weight_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V1LayerParameter.loss_weight) +} +inline void V1LayerParameter::add_loss_weight(float value) { + loss_weight_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V1LayerParameter.loss_weight) +} +inline const ::google::protobuf::RepeatedField< float >& +V1LayerParameter::loss_weight() const { + // @@protoc_insertion_point(field_list:caffe.V1LayerParameter.loss_weight) + return loss_weight_; +} +inline ::google::protobuf::RepeatedField< float >* +V1LayerParameter::mutable_loss_weight() { + // @@protoc_insertion_point(field_mutable_list:caffe.V1LayerParameter.loss_weight) + return &loss_weight_; +} + +// optional .caffe.AccuracyParameter accuracy_param = 27; +inline bool V1LayerParameter::has_accuracy_param() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void V1LayerParameter::set_has_accuracy_param() { + _has_bits_[0] |= 0x00001000u; +} +inline void V1LayerParameter::clear_has_accuracy_param() { + _has_bits_[0] &= ~0x00001000u; +} +inline void V1LayerParameter::clear_accuracy_param() { + if (accuracy_param_ != NULL) accuracy_param_->::caffe::AccuracyParameter::Clear(); + clear_has_accuracy_param(); +} +inline const ::caffe::AccuracyParameter& V1LayerParameter::accuracy_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.accuracy_param) + return accuracy_param_ != NULL ? *accuracy_param_ + : *::caffe::AccuracyParameter::internal_default_instance(); +} +inline ::caffe::AccuracyParameter* V1LayerParameter::mutable_accuracy_param() { + set_has_accuracy_param(); + if (accuracy_param_ == NULL) { + accuracy_param_ = new ::caffe::AccuracyParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.accuracy_param) + return accuracy_param_; +} +inline ::caffe::AccuracyParameter* V1LayerParameter::release_accuracy_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.accuracy_param) + clear_has_accuracy_param(); + ::caffe::AccuracyParameter* temp = accuracy_param_; + accuracy_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param) { + delete accuracy_param_; + accuracy_param_ = accuracy_param; + if (accuracy_param) { + set_has_accuracy_param(); + } else { + clear_has_accuracy_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.accuracy_param) +} + +// optional .caffe.ArgMaxParameter argmax_param = 23; +inline bool V1LayerParameter::has_argmax_param() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void V1LayerParameter::set_has_argmax_param() { + _has_bits_[0] |= 0x00002000u; +} +inline void V1LayerParameter::clear_has_argmax_param() { + _has_bits_[0] &= ~0x00002000u; +} +inline void V1LayerParameter::clear_argmax_param() { + if (argmax_param_ != NULL) argmax_param_->::caffe::ArgMaxParameter::Clear(); + clear_has_argmax_param(); +} +inline const ::caffe::ArgMaxParameter& V1LayerParameter::argmax_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.argmax_param) + return argmax_param_ != NULL ? *argmax_param_ + : *::caffe::ArgMaxParameter::internal_default_instance(); +} +inline ::caffe::ArgMaxParameter* V1LayerParameter::mutable_argmax_param() { + set_has_argmax_param(); + if (argmax_param_ == NULL) { + argmax_param_ = new ::caffe::ArgMaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.argmax_param) + return argmax_param_; +} +inline ::caffe::ArgMaxParameter* V1LayerParameter::release_argmax_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.argmax_param) + clear_has_argmax_param(); + ::caffe::ArgMaxParameter* temp = argmax_param_; + argmax_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param) { + delete argmax_param_; + argmax_param_ = argmax_param; + if (argmax_param) { + set_has_argmax_param(); + } else { + clear_has_argmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.argmax_param) +} + +// optional .caffe.ConcatParameter concat_param = 9; +inline bool V1LayerParameter::has_concat_param() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void V1LayerParameter::set_has_concat_param() { + _has_bits_[0] |= 0x00004000u; +} +inline void V1LayerParameter::clear_has_concat_param() { + _has_bits_[0] &= ~0x00004000u; +} +inline void V1LayerParameter::clear_concat_param() { + if (concat_param_ != NULL) concat_param_->::caffe::ConcatParameter::Clear(); + clear_has_concat_param(); +} +inline const ::caffe::ConcatParameter& V1LayerParameter::concat_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.concat_param) + return concat_param_ != NULL ? *concat_param_ + : *::caffe::ConcatParameter::internal_default_instance(); +} +inline ::caffe::ConcatParameter* V1LayerParameter::mutable_concat_param() { + set_has_concat_param(); + if (concat_param_ == NULL) { + concat_param_ = new ::caffe::ConcatParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.concat_param) + return concat_param_; +} +inline ::caffe::ConcatParameter* V1LayerParameter::release_concat_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.concat_param) + clear_has_concat_param(); + ::caffe::ConcatParameter* temp = concat_param_; + concat_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_concat_param(::caffe::ConcatParameter* concat_param) { + delete concat_param_; + concat_param_ = concat_param; + if (concat_param) { + set_has_concat_param(); + } else { + clear_has_concat_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.concat_param) +} + +// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40; +inline bool V1LayerParameter::has_contrastive_loss_param() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void V1LayerParameter::set_has_contrastive_loss_param() { + _has_bits_[0] |= 0x00008000u; +} +inline void V1LayerParameter::clear_has_contrastive_loss_param() { + _has_bits_[0] &= ~0x00008000u; +} +inline void V1LayerParameter::clear_contrastive_loss_param() { + if (contrastive_loss_param_ != NULL) contrastive_loss_param_->::caffe::ContrastiveLossParameter::Clear(); + clear_has_contrastive_loss_param(); +} +inline const ::caffe::ContrastiveLossParameter& V1LayerParameter::contrastive_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.contrastive_loss_param) + return contrastive_loss_param_ != NULL ? *contrastive_loss_param_ + : *::caffe::ContrastiveLossParameter::internal_default_instance(); +} +inline ::caffe::ContrastiveLossParameter* V1LayerParameter::mutable_contrastive_loss_param() { + set_has_contrastive_loss_param(); + if (contrastive_loss_param_ == NULL) { + contrastive_loss_param_ = new ::caffe::ContrastiveLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.contrastive_loss_param) + return contrastive_loss_param_; +} +inline ::caffe::ContrastiveLossParameter* V1LayerParameter::release_contrastive_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.contrastive_loss_param) + clear_has_contrastive_loss_param(); + ::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_; + contrastive_loss_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param) { + delete contrastive_loss_param_; + contrastive_loss_param_ = contrastive_loss_param; + if (contrastive_loss_param) { + set_has_contrastive_loss_param(); + } else { + clear_has_contrastive_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.contrastive_loss_param) +} + +// optional .caffe.ConvolutionParameter convolution_param = 10; +inline bool V1LayerParameter::has_convolution_param() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +inline void V1LayerParameter::set_has_convolution_param() { + _has_bits_[0] |= 0x00010000u; +} +inline void V1LayerParameter::clear_has_convolution_param() { + _has_bits_[0] &= ~0x00010000u; +} +inline void V1LayerParameter::clear_convolution_param() { + if (convolution_param_ != NULL) convolution_param_->::caffe::ConvolutionParameter::Clear(); + clear_has_convolution_param(); +} +inline const ::caffe::ConvolutionParameter& V1LayerParameter::convolution_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.convolution_param) + return convolution_param_ != NULL ? *convolution_param_ + : *::caffe::ConvolutionParameter::internal_default_instance(); +} +inline ::caffe::ConvolutionParameter* V1LayerParameter::mutable_convolution_param() { + set_has_convolution_param(); + if (convolution_param_ == NULL) { + convolution_param_ = new ::caffe::ConvolutionParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.convolution_param) + return convolution_param_; +} +inline ::caffe::ConvolutionParameter* V1LayerParameter::release_convolution_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.convolution_param) + clear_has_convolution_param(); + ::caffe::ConvolutionParameter* temp = convolution_param_; + convolution_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param) { + delete convolution_param_; + convolution_param_ = convolution_param; + if (convolution_param) { + set_has_convolution_param(); + } else { + clear_has_convolution_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.convolution_param) +} + +// optional .caffe.DataParameter data_param = 11; +inline bool V1LayerParameter::has_data_param() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +inline void V1LayerParameter::set_has_data_param() { + _has_bits_[0] |= 0x00020000u; +} +inline void V1LayerParameter::clear_has_data_param() { + _has_bits_[0] &= ~0x00020000u; +} +inline void V1LayerParameter::clear_data_param() { + if (data_param_ != NULL) data_param_->::caffe::DataParameter::Clear(); + clear_has_data_param(); +} +inline const ::caffe::DataParameter& V1LayerParameter::data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.data_param) + return data_param_ != NULL ? *data_param_ + : *::caffe::DataParameter::internal_default_instance(); +} +inline ::caffe::DataParameter* V1LayerParameter::mutable_data_param() { + set_has_data_param(); + if (data_param_ == NULL) { + data_param_ = new ::caffe::DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.data_param) + return data_param_; +} +inline ::caffe::DataParameter* V1LayerParameter::release_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.data_param) + clear_has_data_param(); + ::caffe::DataParameter* temp = data_param_; + data_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_data_param(::caffe::DataParameter* data_param) { + delete data_param_; + data_param_ = data_param; + if (data_param) { + set_has_data_param(); + } else { + clear_has_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.data_param) +} + +// optional .caffe.DropoutParameter dropout_param = 12; +inline bool V1LayerParameter::has_dropout_param() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +inline void V1LayerParameter::set_has_dropout_param() { + _has_bits_[0] |= 0x00040000u; +} +inline void V1LayerParameter::clear_has_dropout_param() { + _has_bits_[0] &= ~0x00040000u; +} +inline void V1LayerParameter::clear_dropout_param() { + if (dropout_param_ != NULL) dropout_param_->::caffe::DropoutParameter::Clear(); + clear_has_dropout_param(); +} +inline const ::caffe::DropoutParameter& V1LayerParameter::dropout_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.dropout_param) + return dropout_param_ != NULL ? *dropout_param_ + : *::caffe::DropoutParameter::internal_default_instance(); +} +inline ::caffe::DropoutParameter* V1LayerParameter::mutable_dropout_param() { + set_has_dropout_param(); + if (dropout_param_ == NULL) { + dropout_param_ = new ::caffe::DropoutParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.dropout_param) + return dropout_param_; +} +inline ::caffe::DropoutParameter* V1LayerParameter::release_dropout_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.dropout_param) + clear_has_dropout_param(); + ::caffe::DropoutParameter* temp = dropout_param_; + dropout_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param) { + delete dropout_param_; + dropout_param_ = dropout_param; + if (dropout_param) { + set_has_dropout_param(); + } else { + clear_has_dropout_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.dropout_param) +} + +// optional .caffe.DummyDataParameter dummy_data_param = 26; +inline bool V1LayerParameter::has_dummy_data_param() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +inline void V1LayerParameter::set_has_dummy_data_param() { + _has_bits_[0] |= 0x00080000u; +} +inline void V1LayerParameter::clear_has_dummy_data_param() { + _has_bits_[0] &= ~0x00080000u; +} +inline void V1LayerParameter::clear_dummy_data_param() { + if (dummy_data_param_ != NULL) dummy_data_param_->::caffe::DummyDataParameter::Clear(); + clear_has_dummy_data_param(); +} +inline const ::caffe::DummyDataParameter& V1LayerParameter::dummy_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.dummy_data_param) + return dummy_data_param_ != NULL ? *dummy_data_param_ + : *::caffe::DummyDataParameter::internal_default_instance(); +} +inline ::caffe::DummyDataParameter* V1LayerParameter::mutable_dummy_data_param() { + set_has_dummy_data_param(); + if (dummy_data_param_ == NULL) { + dummy_data_param_ = new ::caffe::DummyDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.dummy_data_param) + return dummy_data_param_; +} +inline ::caffe::DummyDataParameter* V1LayerParameter::release_dummy_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.dummy_data_param) + clear_has_dummy_data_param(); + ::caffe::DummyDataParameter* temp = dummy_data_param_; + dummy_data_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param) { + delete dummy_data_param_; + dummy_data_param_ = dummy_data_param; + if (dummy_data_param) { + set_has_dummy_data_param(); + } else { + clear_has_dummy_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.dummy_data_param) +} + +// optional .caffe.EltwiseParameter eltwise_param = 24; +inline bool V1LayerParameter::has_eltwise_param() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +inline void V1LayerParameter::set_has_eltwise_param() { + _has_bits_[0] |= 0x00100000u; +} +inline void V1LayerParameter::clear_has_eltwise_param() { + _has_bits_[0] &= ~0x00100000u; +} +inline void V1LayerParameter::clear_eltwise_param() { + if (eltwise_param_ != NULL) eltwise_param_->::caffe::EltwiseParameter::Clear(); + clear_has_eltwise_param(); +} +inline const ::caffe::EltwiseParameter& V1LayerParameter::eltwise_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.eltwise_param) + return eltwise_param_ != NULL ? *eltwise_param_ + : *::caffe::EltwiseParameter::internal_default_instance(); +} +inline ::caffe::EltwiseParameter* V1LayerParameter::mutable_eltwise_param() { + set_has_eltwise_param(); + if (eltwise_param_ == NULL) { + eltwise_param_ = new ::caffe::EltwiseParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.eltwise_param) + return eltwise_param_; +} +inline ::caffe::EltwiseParameter* V1LayerParameter::release_eltwise_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.eltwise_param) + clear_has_eltwise_param(); + ::caffe::EltwiseParameter* temp = eltwise_param_; + eltwise_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param) { + delete eltwise_param_; + eltwise_param_ = eltwise_param; + if (eltwise_param) { + set_has_eltwise_param(); + } else { + clear_has_eltwise_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.eltwise_param) +} + +// optional .caffe.ExpParameter exp_param = 41; +inline bool V1LayerParameter::has_exp_param() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +inline void V1LayerParameter::set_has_exp_param() { + _has_bits_[0] |= 0x00200000u; +} +inline void V1LayerParameter::clear_has_exp_param() { + _has_bits_[0] &= ~0x00200000u; +} +inline void V1LayerParameter::clear_exp_param() { + if (exp_param_ != NULL) exp_param_->::caffe::ExpParameter::Clear(); + clear_has_exp_param(); +} +inline const ::caffe::ExpParameter& V1LayerParameter::exp_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.exp_param) + return exp_param_ != NULL ? *exp_param_ + : *::caffe::ExpParameter::internal_default_instance(); +} +inline ::caffe::ExpParameter* V1LayerParameter::mutable_exp_param() { + set_has_exp_param(); + if (exp_param_ == NULL) { + exp_param_ = new ::caffe::ExpParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.exp_param) + return exp_param_; +} +inline ::caffe::ExpParameter* V1LayerParameter::release_exp_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.exp_param) + clear_has_exp_param(); + ::caffe::ExpParameter* temp = exp_param_; + exp_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_exp_param(::caffe::ExpParameter* exp_param) { + delete exp_param_; + exp_param_ = exp_param; + if (exp_param) { + set_has_exp_param(); + } else { + clear_has_exp_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.exp_param) +} + +// optional .caffe.HDF5DataParameter hdf5_data_param = 13; +inline bool V1LayerParameter::has_hdf5_data_param() const { + return (_has_bits_[0] & 0x00400000u) != 0; +} +inline void V1LayerParameter::set_has_hdf5_data_param() { + _has_bits_[0] |= 0x00400000u; +} +inline void V1LayerParameter::clear_has_hdf5_data_param() { + _has_bits_[0] &= ~0x00400000u; +} +inline void V1LayerParameter::clear_hdf5_data_param() { + if (hdf5_data_param_ != NULL) hdf5_data_param_->::caffe::HDF5DataParameter::Clear(); + clear_has_hdf5_data_param(); +} +inline const ::caffe::HDF5DataParameter& V1LayerParameter::hdf5_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hdf5_data_param) + return hdf5_data_param_ != NULL ? *hdf5_data_param_ + : *::caffe::HDF5DataParameter::internal_default_instance(); +} +inline ::caffe::HDF5DataParameter* V1LayerParameter::mutable_hdf5_data_param() { + set_has_hdf5_data_param(); + if (hdf5_data_param_ == NULL) { + hdf5_data_param_ = new ::caffe::HDF5DataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hdf5_data_param) + return hdf5_data_param_; +} +inline ::caffe::HDF5DataParameter* V1LayerParameter::release_hdf5_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hdf5_data_param) + clear_has_hdf5_data_param(); + ::caffe::HDF5DataParameter* temp = hdf5_data_param_; + hdf5_data_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param) { + delete hdf5_data_param_; + hdf5_data_param_ = hdf5_data_param; + if (hdf5_data_param) { + set_has_hdf5_data_param(); + } else { + clear_has_hdf5_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hdf5_data_param) +} + +// optional .caffe.HDF5OutputParameter hdf5_output_param = 14; +inline bool V1LayerParameter::has_hdf5_output_param() const { + return (_has_bits_[0] & 0x00800000u) != 0; +} +inline void V1LayerParameter::set_has_hdf5_output_param() { + _has_bits_[0] |= 0x00800000u; +} +inline void V1LayerParameter::clear_has_hdf5_output_param() { + _has_bits_[0] &= ~0x00800000u; +} +inline void V1LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + clear_has_hdf5_output_param(); +} +inline const ::caffe::HDF5OutputParameter& V1LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hdf5_output_param) + return hdf5_output_param_ != NULL ? *hdf5_output_param_ + : *::caffe::HDF5OutputParameter::internal_default_instance(); +} +inline ::caffe::HDF5OutputParameter* V1LayerParameter::mutable_hdf5_output_param() { + set_has_hdf5_output_param(); + if (hdf5_output_param_ == NULL) { + hdf5_output_param_ = new ::caffe::HDF5OutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hdf5_output_param) + return hdf5_output_param_; +} +inline ::caffe::HDF5OutputParameter* V1LayerParameter::release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hdf5_output_param) + clear_has_hdf5_output_param(); + ::caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) { + delete hdf5_output_param_; + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + set_has_hdf5_output_param(); + } else { + clear_has_hdf5_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hdf5_output_param) +} + +// optional .caffe.HingeLossParameter hinge_loss_param = 29; +inline bool V1LayerParameter::has_hinge_loss_param() const { + return (_has_bits_[0] & 0x01000000u) != 0; +} +inline void V1LayerParameter::set_has_hinge_loss_param() { + _has_bits_[0] |= 0x01000000u; +} +inline void V1LayerParameter::clear_has_hinge_loss_param() { + _has_bits_[0] &= ~0x01000000u; +} +inline void V1LayerParameter::clear_hinge_loss_param() { + if (hinge_loss_param_ != NULL) hinge_loss_param_->::caffe::HingeLossParameter::Clear(); + clear_has_hinge_loss_param(); +} +inline const ::caffe::HingeLossParameter& V1LayerParameter::hinge_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.hinge_loss_param) + return hinge_loss_param_ != NULL ? *hinge_loss_param_ + : *::caffe::HingeLossParameter::internal_default_instance(); +} +inline ::caffe::HingeLossParameter* V1LayerParameter::mutable_hinge_loss_param() { + set_has_hinge_loss_param(); + if (hinge_loss_param_ == NULL) { + hinge_loss_param_ = new ::caffe::HingeLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.hinge_loss_param) + return hinge_loss_param_; +} +inline ::caffe::HingeLossParameter* V1LayerParameter::release_hinge_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.hinge_loss_param) + clear_has_hinge_loss_param(); + ::caffe::HingeLossParameter* temp = hinge_loss_param_; + hinge_loss_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param) { + delete hinge_loss_param_; + hinge_loss_param_ = hinge_loss_param; + if (hinge_loss_param) { + set_has_hinge_loss_param(); + } else { + clear_has_hinge_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.hinge_loss_param) +} + +// optional .caffe.ImageDataParameter image_data_param = 15; +inline bool V1LayerParameter::has_image_data_param() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +inline void V1LayerParameter::set_has_image_data_param() { + _has_bits_[0] |= 0x02000000u; +} +inline void V1LayerParameter::clear_has_image_data_param() { + _has_bits_[0] &= ~0x02000000u; +} +inline void V1LayerParameter::clear_image_data_param() { + if (image_data_param_ != NULL) image_data_param_->::caffe::ImageDataParameter::Clear(); + clear_has_image_data_param(); +} +inline const ::caffe::ImageDataParameter& V1LayerParameter::image_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.image_data_param) + return image_data_param_ != NULL ? *image_data_param_ + : *::caffe::ImageDataParameter::internal_default_instance(); +} +inline ::caffe::ImageDataParameter* V1LayerParameter::mutable_image_data_param() { + set_has_image_data_param(); + if (image_data_param_ == NULL) { + image_data_param_ = new ::caffe::ImageDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.image_data_param) + return image_data_param_; +} +inline ::caffe::ImageDataParameter* V1LayerParameter::release_image_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.image_data_param) + clear_has_image_data_param(); + ::caffe::ImageDataParameter* temp = image_data_param_; + image_data_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param) { + delete image_data_param_; + image_data_param_ = image_data_param; + if (image_data_param) { + set_has_image_data_param(); + } else { + clear_has_image_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.image_data_param) +} + +// optional .caffe.InfogainLossParameter infogain_loss_param = 16; +inline bool V1LayerParameter::has_infogain_loss_param() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +inline void V1LayerParameter::set_has_infogain_loss_param() { + _has_bits_[0] |= 0x04000000u; +} +inline void V1LayerParameter::clear_has_infogain_loss_param() { + _has_bits_[0] &= ~0x04000000u; +} +inline void V1LayerParameter::clear_infogain_loss_param() { + if (infogain_loss_param_ != NULL) infogain_loss_param_->::caffe::InfogainLossParameter::Clear(); + clear_has_infogain_loss_param(); +} +inline const ::caffe::InfogainLossParameter& V1LayerParameter::infogain_loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.infogain_loss_param) + return infogain_loss_param_ != NULL ? *infogain_loss_param_ + : *::caffe::InfogainLossParameter::internal_default_instance(); +} +inline ::caffe::InfogainLossParameter* V1LayerParameter::mutable_infogain_loss_param() { + set_has_infogain_loss_param(); + if (infogain_loss_param_ == NULL) { + infogain_loss_param_ = new ::caffe::InfogainLossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.infogain_loss_param) + return infogain_loss_param_; +} +inline ::caffe::InfogainLossParameter* V1LayerParameter::release_infogain_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.infogain_loss_param) + clear_has_infogain_loss_param(); + ::caffe::InfogainLossParameter* temp = infogain_loss_param_; + infogain_loss_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param) { + delete infogain_loss_param_; + infogain_loss_param_ = infogain_loss_param; + if (infogain_loss_param) { + set_has_infogain_loss_param(); + } else { + clear_has_infogain_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.infogain_loss_param) +} + +// optional .caffe.InnerProductParameter inner_product_param = 17; +inline bool V1LayerParameter::has_inner_product_param() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +inline void V1LayerParameter::set_has_inner_product_param() { + _has_bits_[0] |= 0x08000000u; +} +inline void V1LayerParameter::clear_has_inner_product_param() { + _has_bits_[0] &= ~0x08000000u; +} +inline void V1LayerParameter::clear_inner_product_param() { + if (inner_product_param_ != NULL) inner_product_param_->::caffe::InnerProductParameter::Clear(); + clear_has_inner_product_param(); +} +inline const ::caffe::InnerProductParameter& V1LayerParameter::inner_product_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.inner_product_param) + return inner_product_param_ != NULL ? *inner_product_param_ + : *::caffe::InnerProductParameter::internal_default_instance(); +} +inline ::caffe::InnerProductParameter* V1LayerParameter::mutable_inner_product_param() { + set_has_inner_product_param(); + if (inner_product_param_ == NULL) { + inner_product_param_ = new ::caffe::InnerProductParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.inner_product_param) + return inner_product_param_; +} +inline ::caffe::InnerProductParameter* V1LayerParameter::release_inner_product_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.inner_product_param) + clear_has_inner_product_param(); + ::caffe::InnerProductParameter* temp = inner_product_param_; + inner_product_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param) { + delete inner_product_param_; + inner_product_param_ = inner_product_param; + if (inner_product_param) { + set_has_inner_product_param(); + } else { + clear_has_inner_product_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.inner_product_param) +} + +// optional .caffe.LRNParameter lrn_param = 18; +inline bool V1LayerParameter::has_lrn_param() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +inline void V1LayerParameter::set_has_lrn_param() { + _has_bits_[0] |= 0x10000000u; +} +inline void V1LayerParameter::clear_has_lrn_param() { + _has_bits_[0] &= ~0x10000000u; +} +inline void V1LayerParameter::clear_lrn_param() { + if (lrn_param_ != NULL) lrn_param_->::caffe::LRNParameter::Clear(); + clear_has_lrn_param(); +} +inline const ::caffe::LRNParameter& V1LayerParameter::lrn_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.lrn_param) + return lrn_param_ != NULL ? *lrn_param_ + : *::caffe::LRNParameter::internal_default_instance(); +} +inline ::caffe::LRNParameter* V1LayerParameter::mutable_lrn_param() { + set_has_lrn_param(); + if (lrn_param_ == NULL) { + lrn_param_ = new ::caffe::LRNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.lrn_param) + return lrn_param_; +} +inline ::caffe::LRNParameter* V1LayerParameter::release_lrn_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.lrn_param) + clear_has_lrn_param(); + ::caffe::LRNParameter* temp = lrn_param_; + lrn_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_lrn_param(::caffe::LRNParameter* lrn_param) { + delete lrn_param_; + lrn_param_ = lrn_param; + if (lrn_param) { + set_has_lrn_param(); + } else { + clear_has_lrn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.lrn_param) +} + +// optional .caffe.MemoryDataParameter memory_data_param = 22; +inline bool V1LayerParameter::has_memory_data_param() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +inline void V1LayerParameter::set_has_memory_data_param() { + _has_bits_[0] |= 0x20000000u; +} +inline void V1LayerParameter::clear_has_memory_data_param() { + _has_bits_[0] &= ~0x20000000u; +} +inline void V1LayerParameter::clear_memory_data_param() { + if (memory_data_param_ != NULL) memory_data_param_->::caffe::MemoryDataParameter::Clear(); + clear_has_memory_data_param(); +} +inline const ::caffe::MemoryDataParameter& V1LayerParameter::memory_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.memory_data_param) + return memory_data_param_ != NULL ? *memory_data_param_ + : *::caffe::MemoryDataParameter::internal_default_instance(); +} +inline ::caffe::MemoryDataParameter* V1LayerParameter::mutable_memory_data_param() { + set_has_memory_data_param(); + if (memory_data_param_ == NULL) { + memory_data_param_ = new ::caffe::MemoryDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.memory_data_param) + return memory_data_param_; +} +inline ::caffe::MemoryDataParameter* V1LayerParameter::release_memory_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.memory_data_param) + clear_has_memory_data_param(); + ::caffe::MemoryDataParameter* temp = memory_data_param_; + memory_data_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param) { + delete memory_data_param_; + memory_data_param_ = memory_data_param; + if (memory_data_param) { + set_has_memory_data_param(); + } else { + clear_has_memory_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.memory_data_param) +} + +// optional .caffe.MVNParameter mvn_param = 34; +inline bool V1LayerParameter::has_mvn_param() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +inline void V1LayerParameter::set_has_mvn_param() { + _has_bits_[0] |= 0x40000000u; +} +inline void V1LayerParameter::clear_has_mvn_param() { + _has_bits_[0] &= ~0x40000000u; +} +inline void V1LayerParameter::clear_mvn_param() { + if (mvn_param_ != NULL) mvn_param_->::caffe::MVNParameter::Clear(); + clear_has_mvn_param(); +} +inline const ::caffe::MVNParameter& V1LayerParameter::mvn_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.mvn_param) + return mvn_param_ != NULL ? *mvn_param_ + : *::caffe::MVNParameter::internal_default_instance(); +} +inline ::caffe::MVNParameter* V1LayerParameter::mutable_mvn_param() { + set_has_mvn_param(); + if (mvn_param_ == NULL) { + mvn_param_ = new ::caffe::MVNParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.mvn_param) + return mvn_param_; +} +inline ::caffe::MVNParameter* V1LayerParameter::release_mvn_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.mvn_param) + clear_has_mvn_param(); + ::caffe::MVNParameter* temp = mvn_param_; + mvn_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_mvn_param(::caffe::MVNParameter* mvn_param) { + delete mvn_param_; + mvn_param_ = mvn_param; + if (mvn_param) { + set_has_mvn_param(); + } else { + clear_has_mvn_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.mvn_param) +} + +// optional .caffe.PoolingParameter pooling_param = 19; +inline bool V1LayerParameter::has_pooling_param() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +inline void V1LayerParameter::set_has_pooling_param() { + _has_bits_[0] |= 0x80000000u; +} +inline void V1LayerParameter::clear_has_pooling_param() { + _has_bits_[0] &= ~0x80000000u; +} +inline void V1LayerParameter::clear_pooling_param() { + if (pooling_param_ != NULL) pooling_param_->::caffe::PoolingParameter::Clear(); + clear_has_pooling_param(); +} +inline const ::caffe::PoolingParameter& V1LayerParameter::pooling_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.pooling_param) + return pooling_param_ != NULL ? *pooling_param_ + : *::caffe::PoolingParameter::internal_default_instance(); +} +inline ::caffe::PoolingParameter* V1LayerParameter::mutable_pooling_param() { + set_has_pooling_param(); + if (pooling_param_ == NULL) { + pooling_param_ = new ::caffe::PoolingParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.pooling_param) + return pooling_param_; +} +inline ::caffe::PoolingParameter* V1LayerParameter::release_pooling_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.pooling_param) + clear_has_pooling_param(); + ::caffe::PoolingParameter* temp = pooling_param_; + pooling_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param) { + delete pooling_param_; + pooling_param_ = pooling_param; + if (pooling_param) { + set_has_pooling_param(); + } else { + clear_has_pooling_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.pooling_param) +} + +// optional .caffe.PowerParameter power_param = 21; +inline bool V1LayerParameter::has_power_param() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +inline void V1LayerParameter::set_has_power_param() { + _has_bits_[1] |= 0x00000001u; +} +inline void V1LayerParameter::clear_has_power_param() { + _has_bits_[1] &= ~0x00000001u; +} +inline void V1LayerParameter::clear_power_param() { + if (power_param_ != NULL) power_param_->::caffe::PowerParameter::Clear(); + clear_has_power_param(); +} +inline const ::caffe::PowerParameter& V1LayerParameter::power_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.power_param) + return power_param_ != NULL ? *power_param_ + : *::caffe::PowerParameter::internal_default_instance(); +} +inline ::caffe::PowerParameter* V1LayerParameter::mutable_power_param() { + set_has_power_param(); + if (power_param_ == NULL) { + power_param_ = new ::caffe::PowerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.power_param) + return power_param_; +} +inline ::caffe::PowerParameter* V1LayerParameter::release_power_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.power_param) + clear_has_power_param(); + ::caffe::PowerParameter* temp = power_param_; + power_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_power_param(::caffe::PowerParameter* power_param) { + delete power_param_; + power_param_ = power_param; + if (power_param) { + set_has_power_param(); + } else { + clear_has_power_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.power_param) +} + +// optional .caffe.ReLUParameter relu_param = 30; +inline bool V1LayerParameter::has_relu_param() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +inline void V1LayerParameter::set_has_relu_param() { + _has_bits_[1] |= 0x00000002u; +} +inline void V1LayerParameter::clear_has_relu_param() { + _has_bits_[1] &= ~0x00000002u; +} +inline void V1LayerParameter::clear_relu_param() { + if (relu_param_ != NULL) relu_param_->::caffe::ReLUParameter::Clear(); + clear_has_relu_param(); +} +inline const ::caffe::ReLUParameter& V1LayerParameter::relu_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.relu_param) + return relu_param_ != NULL ? *relu_param_ + : *::caffe::ReLUParameter::internal_default_instance(); +} +inline ::caffe::ReLUParameter* V1LayerParameter::mutable_relu_param() { + set_has_relu_param(); + if (relu_param_ == NULL) { + relu_param_ = new ::caffe::ReLUParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.relu_param) + return relu_param_; +} +inline ::caffe::ReLUParameter* V1LayerParameter::release_relu_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.relu_param) + clear_has_relu_param(); + ::caffe::ReLUParameter* temp = relu_param_; + relu_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_relu_param(::caffe::ReLUParameter* relu_param) { + delete relu_param_; + relu_param_ = relu_param; + if (relu_param) { + set_has_relu_param(); + } else { + clear_has_relu_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.relu_param) +} + +// optional .caffe.SigmoidParameter sigmoid_param = 38; +inline bool V1LayerParameter::has_sigmoid_param() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +inline void V1LayerParameter::set_has_sigmoid_param() { + _has_bits_[1] |= 0x00000004u; +} +inline void V1LayerParameter::clear_has_sigmoid_param() { + _has_bits_[1] &= ~0x00000004u; +} +inline void V1LayerParameter::clear_sigmoid_param() { + if (sigmoid_param_ != NULL) sigmoid_param_->::caffe::SigmoidParameter::Clear(); + clear_has_sigmoid_param(); +} +inline const ::caffe::SigmoidParameter& V1LayerParameter::sigmoid_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.sigmoid_param) + return sigmoid_param_ != NULL ? *sigmoid_param_ + : *::caffe::SigmoidParameter::internal_default_instance(); +} +inline ::caffe::SigmoidParameter* V1LayerParameter::mutable_sigmoid_param() { + set_has_sigmoid_param(); + if (sigmoid_param_ == NULL) { + sigmoid_param_ = new ::caffe::SigmoidParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.sigmoid_param) + return sigmoid_param_; +} +inline ::caffe::SigmoidParameter* V1LayerParameter::release_sigmoid_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.sigmoid_param) + clear_has_sigmoid_param(); + ::caffe::SigmoidParameter* temp = sigmoid_param_; + sigmoid_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param) { + delete sigmoid_param_; + sigmoid_param_ = sigmoid_param; + if (sigmoid_param) { + set_has_sigmoid_param(); + } else { + clear_has_sigmoid_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.sigmoid_param) +} + +// optional .caffe.SoftmaxParameter softmax_param = 39; +inline bool V1LayerParameter::has_softmax_param() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +inline void V1LayerParameter::set_has_softmax_param() { + _has_bits_[1] |= 0x00000008u; +} +inline void V1LayerParameter::clear_has_softmax_param() { + _has_bits_[1] &= ~0x00000008u; +} +inline void V1LayerParameter::clear_softmax_param() { + if (softmax_param_ != NULL) softmax_param_->::caffe::SoftmaxParameter::Clear(); + clear_has_softmax_param(); +} +inline const ::caffe::SoftmaxParameter& V1LayerParameter::softmax_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.softmax_param) + return softmax_param_ != NULL ? *softmax_param_ + : *::caffe::SoftmaxParameter::internal_default_instance(); +} +inline ::caffe::SoftmaxParameter* V1LayerParameter::mutable_softmax_param() { + set_has_softmax_param(); + if (softmax_param_ == NULL) { + softmax_param_ = new ::caffe::SoftmaxParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.softmax_param) + return softmax_param_; +} +inline ::caffe::SoftmaxParameter* V1LayerParameter::release_softmax_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.softmax_param) + clear_has_softmax_param(); + ::caffe::SoftmaxParameter* temp = softmax_param_; + softmax_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param) { + delete softmax_param_; + softmax_param_ = softmax_param; + if (softmax_param) { + set_has_softmax_param(); + } else { + clear_has_softmax_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.softmax_param) +} + +// optional .caffe.SliceParameter slice_param = 31; +inline bool V1LayerParameter::has_slice_param() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +inline void V1LayerParameter::set_has_slice_param() { + _has_bits_[1] |= 0x00000010u; +} +inline void V1LayerParameter::clear_has_slice_param() { + _has_bits_[1] &= ~0x00000010u; +} +inline void V1LayerParameter::clear_slice_param() { + if (slice_param_ != NULL) slice_param_->::caffe::SliceParameter::Clear(); + clear_has_slice_param(); +} +inline const ::caffe::SliceParameter& V1LayerParameter::slice_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.slice_param) + return slice_param_ != NULL ? *slice_param_ + : *::caffe::SliceParameter::internal_default_instance(); +} +inline ::caffe::SliceParameter* V1LayerParameter::mutable_slice_param() { + set_has_slice_param(); + if (slice_param_ == NULL) { + slice_param_ = new ::caffe::SliceParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.slice_param) + return slice_param_; +} +inline ::caffe::SliceParameter* V1LayerParameter::release_slice_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.slice_param) + clear_has_slice_param(); + ::caffe::SliceParameter* temp = slice_param_; + slice_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_slice_param(::caffe::SliceParameter* slice_param) { + delete slice_param_; + slice_param_ = slice_param; + if (slice_param) { + set_has_slice_param(); + } else { + clear_has_slice_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.slice_param) +} + +// optional .caffe.TanHParameter tanh_param = 37; +inline bool V1LayerParameter::has_tanh_param() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +inline void V1LayerParameter::set_has_tanh_param() { + _has_bits_[1] |= 0x00000020u; +} +inline void V1LayerParameter::clear_has_tanh_param() { + _has_bits_[1] &= ~0x00000020u; +} +inline void V1LayerParameter::clear_tanh_param() { + if (tanh_param_ != NULL) tanh_param_->::caffe::TanHParameter::Clear(); + clear_has_tanh_param(); +} +inline const ::caffe::TanHParameter& V1LayerParameter::tanh_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.tanh_param) + return tanh_param_ != NULL ? *tanh_param_ + : *::caffe::TanHParameter::internal_default_instance(); +} +inline ::caffe::TanHParameter* V1LayerParameter::mutable_tanh_param() { + set_has_tanh_param(); + if (tanh_param_ == NULL) { + tanh_param_ = new ::caffe::TanHParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.tanh_param) + return tanh_param_; +} +inline ::caffe::TanHParameter* V1LayerParameter::release_tanh_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.tanh_param) + clear_has_tanh_param(); + ::caffe::TanHParameter* temp = tanh_param_; + tanh_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_tanh_param(::caffe::TanHParameter* tanh_param) { + delete tanh_param_; + tanh_param_ = tanh_param; + if (tanh_param) { + set_has_tanh_param(); + } else { + clear_has_tanh_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.tanh_param) +} + +// optional .caffe.ThresholdParameter threshold_param = 25; +inline bool V1LayerParameter::has_threshold_param() const { + return (_has_bits_[1] & 0x00000040u) != 0; +} +inline void V1LayerParameter::set_has_threshold_param() { + _has_bits_[1] |= 0x00000040u; +} +inline void V1LayerParameter::clear_has_threshold_param() { + _has_bits_[1] &= ~0x00000040u; +} +inline void V1LayerParameter::clear_threshold_param() { + if (threshold_param_ != NULL) threshold_param_->::caffe::ThresholdParameter::Clear(); + clear_has_threshold_param(); +} +inline const ::caffe::ThresholdParameter& V1LayerParameter::threshold_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.threshold_param) + return threshold_param_ != NULL ? *threshold_param_ + : *::caffe::ThresholdParameter::internal_default_instance(); +} +inline ::caffe::ThresholdParameter* V1LayerParameter::mutable_threshold_param() { + set_has_threshold_param(); + if (threshold_param_ == NULL) { + threshold_param_ = new ::caffe::ThresholdParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.threshold_param) + return threshold_param_; +} +inline ::caffe::ThresholdParameter* V1LayerParameter::release_threshold_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.threshold_param) + clear_has_threshold_param(); + ::caffe::ThresholdParameter* temp = threshold_param_; + threshold_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param) { + delete threshold_param_; + threshold_param_ = threshold_param; + if (threshold_param) { + set_has_threshold_param(); + } else { + clear_has_threshold_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.threshold_param) +} + +// optional .caffe.WindowDataParameter window_data_param = 20; +inline bool V1LayerParameter::has_window_data_param() const { + return (_has_bits_[1] & 0x00000080u) != 0; +} +inline void V1LayerParameter::set_has_window_data_param() { + _has_bits_[1] |= 0x00000080u; +} +inline void V1LayerParameter::clear_has_window_data_param() { + _has_bits_[1] &= ~0x00000080u; +} +inline void V1LayerParameter::clear_window_data_param() { + if (window_data_param_ != NULL) window_data_param_->::caffe::WindowDataParameter::Clear(); + clear_has_window_data_param(); +} +inline const ::caffe::WindowDataParameter& V1LayerParameter::window_data_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.window_data_param) + return window_data_param_ != NULL ? *window_data_param_ + : *::caffe::WindowDataParameter::internal_default_instance(); +} +inline ::caffe::WindowDataParameter* V1LayerParameter::mutable_window_data_param() { + set_has_window_data_param(); + if (window_data_param_ == NULL) { + window_data_param_ = new ::caffe::WindowDataParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.window_data_param) + return window_data_param_; +} +inline ::caffe::WindowDataParameter* V1LayerParameter::release_window_data_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.window_data_param) + clear_has_window_data_param(); + ::caffe::WindowDataParameter* temp = window_data_param_; + window_data_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param) { + delete window_data_param_; + window_data_param_ = window_data_param; + if (window_data_param) { + set_has_window_data_param(); + } else { + clear_has_window_data_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.window_data_param) +} + +// optional .caffe.TransformationParameter transform_param = 36; +inline bool V1LayerParameter::has_transform_param() const { + return (_has_bits_[1] & 0x00000100u) != 0; +} +inline void V1LayerParameter::set_has_transform_param() { + _has_bits_[1] |= 0x00000100u; +} +inline void V1LayerParameter::clear_has_transform_param() { + _has_bits_[1] &= ~0x00000100u; +} +inline void V1LayerParameter::clear_transform_param() { + if (transform_param_ != NULL) transform_param_->::caffe::TransformationParameter::Clear(); + clear_has_transform_param(); +} +inline const ::caffe::TransformationParameter& V1LayerParameter::transform_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.transform_param) + return transform_param_ != NULL ? *transform_param_ + : *::caffe::TransformationParameter::internal_default_instance(); +} +inline ::caffe::TransformationParameter* V1LayerParameter::mutable_transform_param() { + set_has_transform_param(); + if (transform_param_ == NULL) { + transform_param_ = new ::caffe::TransformationParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.transform_param) + return transform_param_; +} +inline ::caffe::TransformationParameter* V1LayerParameter::release_transform_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.transform_param) + clear_has_transform_param(); + ::caffe::TransformationParameter* temp = transform_param_; + transform_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_transform_param(::caffe::TransformationParameter* transform_param) { + delete transform_param_; + transform_param_ = transform_param; + if (transform_param) { + set_has_transform_param(); + } else { + clear_has_transform_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.transform_param) +} + +// optional .caffe.LossParameter loss_param = 42; +inline bool V1LayerParameter::has_loss_param() const { + return (_has_bits_[1] & 0x00000200u) != 0; +} +inline void V1LayerParameter::set_has_loss_param() { + _has_bits_[1] |= 0x00000200u; +} +inline void V1LayerParameter::clear_has_loss_param() { + _has_bits_[1] &= ~0x00000200u; +} +inline void V1LayerParameter::clear_loss_param() { + if (loss_param_ != NULL) loss_param_->::caffe::LossParameter::Clear(); + clear_has_loss_param(); +} +inline const ::caffe::LossParameter& V1LayerParameter::loss_param() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.loss_param) + return loss_param_ != NULL ? *loss_param_ + : *::caffe::LossParameter::internal_default_instance(); +} +inline ::caffe::LossParameter* V1LayerParameter::mutable_loss_param() { + set_has_loss_param(); + if (loss_param_ == NULL) { + loss_param_ = new ::caffe::LossParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.loss_param) + return loss_param_; +} +inline ::caffe::LossParameter* V1LayerParameter::release_loss_param() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.loss_param) + clear_has_loss_param(); + ::caffe::LossParameter* temp = loss_param_; + loss_param_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_loss_param(::caffe::LossParameter* loss_param) { + delete loss_param_; + loss_param_ = loss_param; + if (loss_param) { + set_has_loss_param(); + } else { + clear_has_loss_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.loss_param) +} + +// optional .caffe.V0LayerParameter layer = 1; +inline bool V1LayerParameter::has_layer() const { + return (_has_bits_[1] & 0x00000400u) != 0; +} +inline void V1LayerParameter::set_has_layer() { + _has_bits_[1] |= 0x00000400u; +} +inline void V1LayerParameter::clear_has_layer() { + _has_bits_[1] &= ~0x00000400u; +} +inline void V1LayerParameter::clear_layer() { + if (layer_ != NULL) layer_->::caffe::V0LayerParameter::Clear(); + clear_has_layer(); +} +inline const ::caffe::V0LayerParameter& V1LayerParameter::layer() const { + // @@protoc_insertion_point(field_get:caffe.V1LayerParameter.layer) + return layer_ != NULL ? *layer_ + : *::caffe::V0LayerParameter::internal_default_instance(); +} +inline ::caffe::V0LayerParameter* V1LayerParameter::mutable_layer() { + set_has_layer(); + if (layer_ == NULL) { + layer_ = new ::caffe::V0LayerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V1LayerParameter.layer) + return layer_; +} +inline ::caffe::V0LayerParameter* V1LayerParameter::release_layer() { + // @@protoc_insertion_point(field_release:caffe.V1LayerParameter.layer) + clear_has_layer(); + ::caffe::V0LayerParameter* temp = layer_; + layer_ = NULL; + return temp; +} +inline void V1LayerParameter::set_allocated_layer(::caffe::V0LayerParameter* layer) { + delete layer_; + layer_ = layer; + if (layer) { + set_has_layer(); + } else { + clear_has_layer(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V1LayerParameter.layer) +} + +inline const V1LayerParameter* V1LayerParameter::internal_default_instance() { + return &V1LayerParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// V0LayerParameter + +// optional string name = 1; +inline bool V0LayerParameter::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void V0LayerParameter::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void V0LayerParameter::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void V0LayerParameter::clear_name() { + name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_name(); +} +inline const ::std::string& V0LayerParameter::name() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.name) + return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_name(const ::std::string& value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.name) +} +inline void V0LayerParameter::set_name(const char* value) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.name) +} +inline void V0LayerParameter::set_name(const char* value, size_t size) { + set_has_name(); + name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.name) +} +inline ::std::string* V0LayerParameter::mutable_name() { + set_has_name(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.name) + return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* V0LayerParameter::release_name() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.name) + clear_has_name(); + return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_allocated_name(::std::string* name) { + if (name != NULL) { + set_has_name(); + } else { + clear_has_name(); + } + name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.name) +} + +// optional string type = 2; +inline bool V0LayerParameter::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void V0LayerParameter::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void V0LayerParameter::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void V0LayerParameter::clear_type() { + type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_type(); +} +inline const ::std::string& V0LayerParameter::type() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.type) + return type_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_type(const ::std::string& value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.type) +} +inline void V0LayerParameter::set_type(const char* value) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.type) +} +inline void V0LayerParameter::set_type(const char* value, size_t size) { + set_has_type(); + type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.type) +} +inline ::std::string* V0LayerParameter::mutable_type() { + set_has_type(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.type) + return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* V0LayerParameter::release_type() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.type) + clear_has_type(); + return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_allocated_type(::std::string* type) { + if (type != NULL) { + set_has_type(); + } else { + clear_has_type(); + } + type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.type) +} + +// optional uint32 num_output = 3; +inline bool V0LayerParameter::has_num_output() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void V0LayerParameter::set_has_num_output() { + _has_bits_[0] |= 0x00000004u; +} +inline void V0LayerParameter::clear_has_num_output() { + _has_bits_[0] &= ~0x00000004u; +} +inline void V0LayerParameter::clear_num_output() { + num_output_ = 0u; + clear_has_num_output(); +} +inline ::google::protobuf::uint32 V0LayerParameter::num_output() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.num_output) + return num_output_; +} +inline void V0LayerParameter::set_num_output(::google::protobuf::uint32 value) { + set_has_num_output(); + num_output_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.num_output) +} + +// optional bool biasterm = 4 [default = true]; +inline bool V0LayerParameter::has_biasterm() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void V0LayerParameter::set_has_biasterm() { + _has_bits_[0] |= 0x00000008u; +} +inline void V0LayerParameter::clear_has_biasterm() { + _has_bits_[0] &= ~0x00000008u; +} +inline void V0LayerParameter::clear_biasterm() { + biasterm_ = true; + clear_has_biasterm(); +} +inline bool V0LayerParameter::biasterm() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.biasterm) + return biasterm_; +} +inline void V0LayerParameter::set_biasterm(bool value) { + set_has_biasterm(); + biasterm_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.biasterm) +} + +// optional .caffe.FillerParameter weight_filler = 5; +inline bool V0LayerParameter::has_weight_filler() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void V0LayerParameter::set_has_weight_filler() { + _has_bits_[0] |= 0x00000010u; +} +inline void V0LayerParameter::clear_has_weight_filler() { + _has_bits_[0] &= ~0x00000010u; +} +inline void V0LayerParameter::clear_weight_filler() { + if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear(); + clear_has_weight_filler(); +} +inline const ::caffe::FillerParameter& V0LayerParameter::weight_filler() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.weight_filler) + return weight_filler_ != NULL ? *weight_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* V0LayerParameter::mutable_weight_filler() { + set_has_weight_filler(); + if (weight_filler_ == NULL) { + weight_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.weight_filler) + return weight_filler_; +} +inline ::caffe::FillerParameter* V0LayerParameter::release_weight_filler() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.weight_filler) + clear_has_weight_filler(); + ::caffe::FillerParameter* temp = weight_filler_; + weight_filler_ = NULL; + return temp; +} +inline void V0LayerParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) { + delete weight_filler_; + weight_filler_ = weight_filler; + if (weight_filler) { + set_has_weight_filler(); + } else { + clear_has_weight_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.weight_filler) +} + +// optional .caffe.FillerParameter bias_filler = 6; +inline bool V0LayerParameter::has_bias_filler() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void V0LayerParameter::set_has_bias_filler() { + _has_bits_[0] |= 0x00000020u; +} +inline void V0LayerParameter::clear_has_bias_filler() { + _has_bits_[0] &= ~0x00000020u; +} +inline void V0LayerParameter::clear_bias_filler() { + if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear(); + clear_has_bias_filler(); +} +inline const ::caffe::FillerParameter& V0LayerParameter::bias_filler() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.bias_filler) + return bias_filler_ != NULL ? *bias_filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* V0LayerParameter::mutable_bias_filler() { + set_has_bias_filler(); + if (bias_filler_ == NULL) { + bias_filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.bias_filler) + return bias_filler_; +} +inline ::caffe::FillerParameter* V0LayerParameter::release_bias_filler() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.bias_filler) + clear_has_bias_filler(); + ::caffe::FillerParameter* temp = bias_filler_; + bias_filler_ = NULL; + return temp; +} +inline void V0LayerParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) { + delete bias_filler_; + bias_filler_ = bias_filler; + if (bias_filler) { + set_has_bias_filler(); + } else { + clear_has_bias_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.bias_filler) +} + +// optional uint32 pad = 7 [default = 0]; +inline bool V0LayerParameter::has_pad() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void V0LayerParameter::set_has_pad() { + _has_bits_[0] |= 0x00000040u; +} +inline void V0LayerParameter::clear_has_pad() { + _has_bits_[0] &= ~0x00000040u; +} +inline void V0LayerParameter::clear_pad() { + pad_ = 0u; + clear_has_pad(); +} +inline ::google::protobuf::uint32 V0LayerParameter::pad() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.pad) + return pad_; +} +inline void V0LayerParameter::set_pad(::google::protobuf::uint32 value) { + set_has_pad(); + pad_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.pad) +} + +// optional uint32 kernelsize = 8; +inline bool V0LayerParameter::has_kernelsize() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void V0LayerParameter::set_has_kernelsize() { + _has_bits_[0] |= 0x00000080u; +} +inline void V0LayerParameter::clear_has_kernelsize() { + _has_bits_[0] &= ~0x00000080u; +} +inline void V0LayerParameter::clear_kernelsize() { + kernelsize_ = 0u; + clear_has_kernelsize(); +} +inline ::google::protobuf::uint32 V0LayerParameter::kernelsize() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.kernelsize) + return kernelsize_; +} +inline void V0LayerParameter::set_kernelsize(::google::protobuf::uint32 value) { + set_has_kernelsize(); + kernelsize_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.kernelsize) +} + +// optional uint32 group = 9 [default = 1]; +inline bool V0LayerParameter::has_group() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void V0LayerParameter::set_has_group() { + _has_bits_[0] |= 0x00000100u; +} +inline void V0LayerParameter::clear_has_group() { + _has_bits_[0] &= ~0x00000100u; +} +inline void V0LayerParameter::clear_group() { + group_ = 1u; + clear_has_group(); +} +inline ::google::protobuf::uint32 V0LayerParameter::group() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.group) + return group_; +} +inline void V0LayerParameter::set_group(::google::protobuf::uint32 value) { + set_has_group(); + group_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.group) +} + +// optional uint32 stride = 10 [default = 1]; +inline bool V0LayerParameter::has_stride() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void V0LayerParameter::set_has_stride() { + _has_bits_[0] |= 0x00000200u; +} +inline void V0LayerParameter::clear_has_stride() { + _has_bits_[0] &= ~0x00000200u; +} +inline void V0LayerParameter::clear_stride() { + stride_ = 1u; + clear_has_stride(); +} +inline ::google::protobuf::uint32 V0LayerParameter::stride() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.stride) + return stride_; +} +inline void V0LayerParameter::set_stride(::google::protobuf::uint32 value) { + set_has_stride(); + stride_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.stride) +} + +// optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX]; +inline bool V0LayerParameter::has_pool() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void V0LayerParameter::set_has_pool() { + _has_bits_[0] |= 0x00000400u; +} +inline void V0LayerParameter::clear_has_pool() { + _has_bits_[0] &= ~0x00000400u; +} +inline void V0LayerParameter::clear_pool() { + pool_ = 0; + clear_has_pool(); +} +inline ::caffe::V0LayerParameter_PoolMethod V0LayerParameter::pool() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.pool) + return static_cast< ::caffe::V0LayerParameter_PoolMethod >(pool_); +} +inline void V0LayerParameter::set_pool(::caffe::V0LayerParameter_PoolMethod value) { + assert(::caffe::V0LayerParameter_PoolMethod_IsValid(value)); + set_has_pool(); + pool_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.pool) +} + +// optional float dropout_ratio = 12 [default = 0.5]; +inline bool V0LayerParameter::has_dropout_ratio() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void V0LayerParameter::set_has_dropout_ratio() { + _has_bits_[0] |= 0x00000800u; +} +inline void V0LayerParameter::clear_has_dropout_ratio() { + _has_bits_[0] &= ~0x00000800u; +} +inline void V0LayerParameter::clear_dropout_ratio() { + dropout_ratio_ = 0.5f; + clear_has_dropout_ratio(); +} +inline float V0LayerParameter::dropout_ratio() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.dropout_ratio) + return dropout_ratio_; +} +inline void V0LayerParameter::set_dropout_ratio(float value) { + set_has_dropout_ratio(); + dropout_ratio_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.dropout_ratio) +} + +// optional uint32 local_size = 13 [default = 5]; +inline bool V0LayerParameter::has_local_size() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void V0LayerParameter::set_has_local_size() { + _has_bits_[0] |= 0x00001000u; +} +inline void V0LayerParameter::clear_has_local_size() { + _has_bits_[0] &= ~0x00001000u; +} +inline void V0LayerParameter::clear_local_size() { + local_size_ = 5u; + clear_has_local_size(); +} +inline ::google::protobuf::uint32 V0LayerParameter::local_size() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.local_size) + return local_size_; +} +inline void V0LayerParameter::set_local_size(::google::protobuf::uint32 value) { + set_has_local_size(); + local_size_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.local_size) +} + +// optional float alpha = 14 [default = 1]; +inline bool V0LayerParameter::has_alpha() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void V0LayerParameter::set_has_alpha() { + _has_bits_[0] |= 0x00002000u; +} +inline void V0LayerParameter::clear_has_alpha() { + _has_bits_[0] &= ~0x00002000u; +} +inline void V0LayerParameter::clear_alpha() { + alpha_ = 1; + clear_has_alpha(); +} +inline float V0LayerParameter::alpha() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.alpha) + return alpha_; +} +inline void V0LayerParameter::set_alpha(float value) { + set_has_alpha(); + alpha_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.alpha) +} + +// optional float beta = 15 [default = 0.75]; +inline bool V0LayerParameter::has_beta() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void V0LayerParameter::set_has_beta() { + _has_bits_[0] |= 0x00004000u; +} +inline void V0LayerParameter::clear_has_beta() { + _has_bits_[0] &= ~0x00004000u; +} +inline void V0LayerParameter::clear_beta() { + beta_ = 0.75f; + clear_has_beta(); +} +inline float V0LayerParameter::beta() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.beta) + return beta_; +} +inline void V0LayerParameter::set_beta(float value) { + set_has_beta(); + beta_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.beta) +} + +// optional float k = 22 [default = 1]; +inline bool V0LayerParameter::has_k() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void V0LayerParameter::set_has_k() { + _has_bits_[0] |= 0x00008000u; +} +inline void V0LayerParameter::clear_has_k() { + _has_bits_[0] &= ~0x00008000u; +} +inline void V0LayerParameter::clear_k() { + k_ = 1; + clear_has_k(); +} +inline float V0LayerParameter::k() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.k) + return k_; +} +inline void V0LayerParameter::set_k(float value) { + set_has_k(); + k_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.k) +} + +// optional string source = 16; +inline bool V0LayerParameter::has_source() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +inline void V0LayerParameter::set_has_source() { + _has_bits_[0] |= 0x00010000u; +} +inline void V0LayerParameter::clear_has_source() { + _has_bits_[0] &= ~0x00010000u; +} +inline void V0LayerParameter::clear_source() { + source_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_source(); +} +inline const ::std::string& V0LayerParameter::source() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.source) + return source_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_source(const ::std::string& value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.source) +} +inline void V0LayerParameter::set_source(const char* value) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.source) +} +inline void V0LayerParameter::set_source(const char* value, size_t size) { + set_has_source(); + source_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.source) +} +inline ::std::string* V0LayerParameter::mutable_source() { + set_has_source(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.source) + return source_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* V0LayerParameter::release_source() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.source) + clear_has_source(); + return source_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_allocated_source(::std::string* source) { + if (source != NULL) { + set_has_source(); + } else { + clear_has_source(); + } + source_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.source) +} + +// optional float scale = 17 [default = 1]; +inline bool V0LayerParameter::has_scale() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +inline void V0LayerParameter::set_has_scale() { + _has_bits_[0] |= 0x00020000u; +} +inline void V0LayerParameter::clear_has_scale() { + _has_bits_[0] &= ~0x00020000u; +} +inline void V0LayerParameter::clear_scale() { + scale_ = 1; + clear_has_scale(); +} +inline float V0LayerParameter::scale() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.scale) + return scale_; +} +inline void V0LayerParameter::set_scale(float value) { + set_has_scale(); + scale_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.scale) +} + +// optional string meanfile = 18; +inline bool V0LayerParameter::has_meanfile() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +inline void V0LayerParameter::set_has_meanfile() { + _has_bits_[0] |= 0x00040000u; +} +inline void V0LayerParameter::clear_has_meanfile() { + _has_bits_[0] &= ~0x00040000u; +} +inline void V0LayerParameter::clear_meanfile() { + meanfile_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_meanfile(); +} +inline const ::std::string& V0LayerParameter::meanfile() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.meanfile) + return meanfile_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_meanfile(const ::std::string& value) { + set_has_meanfile(); + meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.meanfile) +} +inline void V0LayerParameter::set_meanfile(const char* value) { + set_has_meanfile(); + meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.meanfile) +} +inline void V0LayerParameter::set_meanfile(const char* value, size_t size) { + set_has_meanfile(); + meanfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.meanfile) +} +inline ::std::string* V0LayerParameter::mutable_meanfile() { + set_has_meanfile(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.meanfile) + return meanfile_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* V0LayerParameter::release_meanfile() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.meanfile) + clear_has_meanfile(); + return meanfile_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void V0LayerParameter::set_allocated_meanfile(::std::string* meanfile) { + if (meanfile != NULL) { + set_has_meanfile(); + } else { + clear_has_meanfile(); + } + meanfile_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), meanfile); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.meanfile) +} + +// optional uint32 batchsize = 19; +inline bool V0LayerParameter::has_batchsize() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +inline void V0LayerParameter::set_has_batchsize() { + _has_bits_[0] |= 0x00080000u; +} +inline void V0LayerParameter::clear_has_batchsize() { + _has_bits_[0] &= ~0x00080000u; +} +inline void V0LayerParameter::clear_batchsize() { + batchsize_ = 0u; + clear_has_batchsize(); +} +inline ::google::protobuf::uint32 V0LayerParameter::batchsize() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.batchsize) + return batchsize_; +} +inline void V0LayerParameter::set_batchsize(::google::protobuf::uint32 value) { + set_has_batchsize(); + batchsize_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.batchsize) +} + +// optional uint32 cropsize = 20 [default = 0]; +inline bool V0LayerParameter::has_cropsize() const { + return (_has_bits_[0] & 0x00100000u) != 0; +} +inline void V0LayerParameter::set_has_cropsize() { + _has_bits_[0] |= 0x00100000u; +} +inline void V0LayerParameter::clear_has_cropsize() { + _has_bits_[0] &= ~0x00100000u; +} +inline void V0LayerParameter::clear_cropsize() { + cropsize_ = 0u; + clear_has_cropsize(); +} +inline ::google::protobuf::uint32 V0LayerParameter::cropsize() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.cropsize) + return cropsize_; +} +inline void V0LayerParameter::set_cropsize(::google::protobuf::uint32 value) { + set_has_cropsize(); + cropsize_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.cropsize) +} + +// optional bool mirror = 21 [default = false]; +inline bool V0LayerParameter::has_mirror() const { + return (_has_bits_[0] & 0x00200000u) != 0; +} +inline void V0LayerParameter::set_has_mirror() { + _has_bits_[0] |= 0x00200000u; +} +inline void V0LayerParameter::clear_has_mirror() { + _has_bits_[0] &= ~0x00200000u; +} +inline void V0LayerParameter::clear_mirror() { + mirror_ = false; + clear_has_mirror(); +} +inline bool V0LayerParameter::mirror() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.mirror) + return mirror_; +} +inline void V0LayerParameter::set_mirror(bool value) { + set_has_mirror(); + mirror_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.mirror) +} + +// repeated .caffe.BlobProto blobs = 50; +inline int V0LayerParameter::blobs_size() const { + return blobs_.size(); +} +inline void V0LayerParameter::clear_blobs() { + blobs_.Clear(); +} +inline const ::caffe::BlobProto& V0LayerParameter::blobs(int index) const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.blobs) + return blobs_.Get(index); +} +inline ::caffe::BlobProto* V0LayerParameter::mutable_blobs(int index) { + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.blobs) + return blobs_.Mutable(index); +} +inline ::caffe::BlobProto* V0LayerParameter::add_blobs() { + // @@protoc_insertion_point(field_add:caffe.V0LayerParameter.blobs) + return blobs_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >* +V0LayerParameter::mutable_blobs() { + // @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.blobs) + return &blobs_; +} +inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >& +V0LayerParameter::blobs() const { + // @@protoc_insertion_point(field_list:caffe.V0LayerParameter.blobs) + return blobs_; +} + +// repeated float blobs_lr = 51; +inline int V0LayerParameter::blobs_lr_size() const { + return blobs_lr_.size(); +} +inline void V0LayerParameter::clear_blobs_lr() { + blobs_lr_.Clear(); +} +inline float V0LayerParameter::blobs_lr(int index) const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.blobs_lr) + return blobs_lr_.Get(index); +} +inline void V0LayerParameter::set_blobs_lr(int index, float value) { + blobs_lr_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.blobs_lr) +} +inline void V0LayerParameter::add_blobs_lr(float value) { + blobs_lr_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V0LayerParameter.blobs_lr) +} +inline const ::google::protobuf::RepeatedField< float >& +V0LayerParameter::blobs_lr() const { + // @@protoc_insertion_point(field_list:caffe.V0LayerParameter.blobs_lr) + return blobs_lr_; +} +inline ::google::protobuf::RepeatedField< float >* +V0LayerParameter::mutable_blobs_lr() { + // @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.blobs_lr) + return &blobs_lr_; +} + +// repeated float weight_decay = 52; +inline int V0LayerParameter::weight_decay_size() const { + return weight_decay_.size(); +} +inline void V0LayerParameter::clear_weight_decay() { + weight_decay_.Clear(); +} +inline float V0LayerParameter::weight_decay(int index) const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.weight_decay) + return weight_decay_.Get(index); +} +inline void V0LayerParameter::set_weight_decay(int index, float value) { + weight_decay_.Set(index, value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.weight_decay) +} +inline void V0LayerParameter::add_weight_decay(float value) { + weight_decay_.Add(value); + // @@protoc_insertion_point(field_add:caffe.V0LayerParameter.weight_decay) +} +inline const ::google::protobuf::RepeatedField< float >& +V0LayerParameter::weight_decay() const { + // @@protoc_insertion_point(field_list:caffe.V0LayerParameter.weight_decay) + return weight_decay_; +} +inline ::google::protobuf::RepeatedField< float >* +V0LayerParameter::mutable_weight_decay() { + // @@protoc_insertion_point(field_mutable_list:caffe.V0LayerParameter.weight_decay) + return &weight_decay_; +} + +// optional uint32 rand_skip = 53 [default = 0]; +inline bool V0LayerParameter::has_rand_skip() const { + return (_has_bits_[0] & 0x02000000u) != 0; +} +inline void V0LayerParameter::set_has_rand_skip() { + _has_bits_[0] |= 0x02000000u; +} +inline void V0LayerParameter::clear_has_rand_skip() { + _has_bits_[0] &= ~0x02000000u; +} +inline void V0LayerParameter::clear_rand_skip() { + rand_skip_ = 0u; + clear_has_rand_skip(); +} +inline ::google::protobuf::uint32 V0LayerParameter::rand_skip() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.rand_skip) + return rand_skip_; +} +inline void V0LayerParameter::set_rand_skip(::google::protobuf::uint32 value) { + set_has_rand_skip(); + rand_skip_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.rand_skip) +} + +// optional float det_fg_threshold = 54 [default = 0.5]; +inline bool V0LayerParameter::has_det_fg_threshold() const { + return (_has_bits_[0] & 0x04000000u) != 0; +} +inline void V0LayerParameter::set_has_det_fg_threshold() { + _has_bits_[0] |= 0x04000000u; +} +inline void V0LayerParameter::clear_has_det_fg_threshold() { + _has_bits_[0] &= ~0x04000000u; +} +inline void V0LayerParameter::clear_det_fg_threshold() { + det_fg_threshold_ = 0.5f; + clear_has_det_fg_threshold(); +} +inline float V0LayerParameter::det_fg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_fg_threshold) + return det_fg_threshold_; +} +inline void V0LayerParameter::set_det_fg_threshold(float value) { + set_has_det_fg_threshold(); + det_fg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_fg_threshold) +} + +// optional float det_bg_threshold = 55 [default = 0.5]; +inline bool V0LayerParameter::has_det_bg_threshold() const { + return (_has_bits_[0] & 0x08000000u) != 0; +} +inline void V0LayerParameter::set_has_det_bg_threshold() { + _has_bits_[0] |= 0x08000000u; +} +inline void V0LayerParameter::clear_has_det_bg_threshold() { + _has_bits_[0] &= ~0x08000000u; +} +inline void V0LayerParameter::clear_det_bg_threshold() { + det_bg_threshold_ = 0.5f; + clear_has_det_bg_threshold(); +} +inline float V0LayerParameter::det_bg_threshold() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_bg_threshold) + return det_bg_threshold_; +} +inline void V0LayerParameter::set_det_bg_threshold(float value) { + set_has_det_bg_threshold(); + det_bg_threshold_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_bg_threshold) +} + +// optional float det_fg_fraction = 56 [default = 0.25]; +inline bool V0LayerParameter::has_det_fg_fraction() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +inline void V0LayerParameter::set_has_det_fg_fraction() { + _has_bits_[0] |= 0x10000000u; +} +inline void V0LayerParameter::clear_has_det_fg_fraction() { + _has_bits_[0] &= ~0x10000000u; +} +inline void V0LayerParameter::clear_det_fg_fraction() { + det_fg_fraction_ = 0.25f; + clear_has_det_fg_fraction(); +} +inline float V0LayerParameter::det_fg_fraction() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_fg_fraction) + return det_fg_fraction_; +} +inline void V0LayerParameter::set_det_fg_fraction(float value) { + set_has_det_fg_fraction(); + det_fg_fraction_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_fg_fraction) +} + +// optional uint32 det_context_pad = 58 [default = 0]; +inline bool V0LayerParameter::has_det_context_pad() const { + return (_has_bits_[0] & 0x20000000u) != 0; +} +inline void V0LayerParameter::set_has_det_context_pad() { + _has_bits_[0] |= 0x20000000u; +} +inline void V0LayerParameter::clear_has_det_context_pad() { + _has_bits_[0] &= ~0x20000000u; +} +inline void V0LayerParameter::clear_det_context_pad() { + det_context_pad_ = 0u; + clear_has_det_context_pad(); +} +inline ::google::protobuf::uint32 V0LayerParameter::det_context_pad() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_context_pad) + return det_context_pad_; +} +inline void V0LayerParameter::set_det_context_pad(::google::protobuf::uint32 value) { + set_has_det_context_pad(); + det_context_pad_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_context_pad) +} + +// optional string det_crop_mode = 59 [default = "warp"]; +inline bool V0LayerParameter::has_det_crop_mode() const { + return (_has_bits_[0] & 0x40000000u) != 0; +} +inline void V0LayerParameter::set_has_det_crop_mode() { + _has_bits_[0] |= 0x40000000u; +} +inline void V0LayerParameter::clear_has_det_crop_mode() { + _has_bits_[0] &= ~0x40000000u; +} +inline void V0LayerParameter::clear_det_crop_mode() { + det_crop_mode_.ClearToDefaultNoArena(_default_det_crop_mode_); + clear_has_det_crop_mode(); +} +inline const ::std::string& V0LayerParameter::det_crop_mode() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.det_crop_mode) + return det_crop_mode_.GetNoArena(_default_det_crop_mode_); +} +inline void V0LayerParameter::set_det_crop_mode(const ::std::string& value) { + set_has_det_crop_mode(); + det_crop_mode_.SetNoArena(_default_det_crop_mode_, value); + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.det_crop_mode) +} +inline void V0LayerParameter::set_det_crop_mode(const char* value) { + set_has_det_crop_mode(); + det_crop_mode_.SetNoArena(_default_det_crop_mode_, ::std::string(value)); + // @@protoc_insertion_point(field_set_char:caffe.V0LayerParameter.det_crop_mode) +} +inline void V0LayerParameter::set_det_crop_mode(const char* value, size_t size) { + set_has_det_crop_mode(); + det_crop_mode_.SetNoArena(_default_det_crop_mode_, + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:caffe.V0LayerParameter.det_crop_mode) +} +inline ::std::string* V0LayerParameter::mutable_det_crop_mode() { + set_has_det_crop_mode(); + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.det_crop_mode) + return det_crop_mode_.MutableNoArena(_default_det_crop_mode_); +} +inline ::std::string* V0LayerParameter::release_det_crop_mode() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.det_crop_mode) + clear_has_det_crop_mode(); + return det_crop_mode_.ReleaseNoArena(_default_det_crop_mode_); +} +inline void V0LayerParameter::set_allocated_det_crop_mode(::std::string* det_crop_mode) { + if (det_crop_mode != NULL) { + set_has_det_crop_mode(); + } else { + clear_has_det_crop_mode(); + } + det_crop_mode_.SetAllocatedNoArena(_default_det_crop_mode_, det_crop_mode); + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.det_crop_mode) +} + +// optional int32 new_num = 60 [default = 0]; +inline bool V0LayerParameter::has_new_num() const { + return (_has_bits_[0] & 0x80000000u) != 0; +} +inline void V0LayerParameter::set_has_new_num() { + _has_bits_[0] |= 0x80000000u; +} +inline void V0LayerParameter::clear_has_new_num() { + _has_bits_[0] &= ~0x80000000u; +} +inline void V0LayerParameter::clear_new_num() { + new_num_ = 0; + clear_has_new_num(); +} +inline ::google::protobuf::int32 V0LayerParameter::new_num() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_num) + return new_num_; +} +inline void V0LayerParameter::set_new_num(::google::protobuf::int32 value) { + set_has_new_num(); + new_num_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_num) +} + +// optional int32 new_channels = 61 [default = 0]; +inline bool V0LayerParameter::has_new_channels() const { + return (_has_bits_[1] & 0x00000001u) != 0; +} +inline void V0LayerParameter::set_has_new_channels() { + _has_bits_[1] |= 0x00000001u; +} +inline void V0LayerParameter::clear_has_new_channels() { + _has_bits_[1] &= ~0x00000001u; +} +inline void V0LayerParameter::clear_new_channels() { + new_channels_ = 0; + clear_has_new_channels(); +} +inline ::google::protobuf::int32 V0LayerParameter::new_channels() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_channels) + return new_channels_; +} +inline void V0LayerParameter::set_new_channels(::google::protobuf::int32 value) { + set_has_new_channels(); + new_channels_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_channels) +} + +// optional int32 new_height = 62 [default = 0]; +inline bool V0LayerParameter::has_new_height() const { + return (_has_bits_[1] & 0x00000002u) != 0; +} +inline void V0LayerParameter::set_has_new_height() { + _has_bits_[1] |= 0x00000002u; +} +inline void V0LayerParameter::clear_has_new_height() { + _has_bits_[1] &= ~0x00000002u; +} +inline void V0LayerParameter::clear_new_height() { + new_height_ = 0; + clear_has_new_height(); +} +inline ::google::protobuf::int32 V0LayerParameter::new_height() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_height) + return new_height_; +} +inline void V0LayerParameter::set_new_height(::google::protobuf::int32 value) { + set_has_new_height(); + new_height_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_height) +} + +// optional int32 new_width = 63 [default = 0]; +inline bool V0LayerParameter::has_new_width() const { + return (_has_bits_[1] & 0x00000004u) != 0; +} +inline void V0LayerParameter::set_has_new_width() { + _has_bits_[1] |= 0x00000004u; +} +inline void V0LayerParameter::clear_has_new_width() { + _has_bits_[1] &= ~0x00000004u; +} +inline void V0LayerParameter::clear_new_width() { + new_width_ = 0; + clear_has_new_width(); +} +inline ::google::protobuf::int32 V0LayerParameter::new_width() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.new_width) + return new_width_; +} +inline void V0LayerParameter::set_new_width(::google::protobuf::int32 value) { + set_has_new_width(); + new_width_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.new_width) +} + +// optional bool shuffle_images = 64 [default = false]; +inline bool V0LayerParameter::has_shuffle_images() const { + return (_has_bits_[1] & 0x00000008u) != 0; +} +inline void V0LayerParameter::set_has_shuffle_images() { + _has_bits_[1] |= 0x00000008u; +} +inline void V0LayerParameter::clear_has_shuffle_images() { + _has_bits_[1] &= ~0x00000008u; +} +inline void V0LayerParameter::clear_shuffle_images() { + shuffle_images_ = false; + clear_has_shuffle_images(); +} +inline bool V0LayerParameter::shuffle_images() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.shuffle_images) + return shuffle_images_; +} +inline void V0LayerParameter::set_shuffle_images(bool value) { + set_has_shuffle_images(); + shuffle_images_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.shuffle_images) +} + +// optional uint32 concat_dim = 65 [default = 1]; +inline bool V0LayerParameter::has_concat_dim() const { + return (_has_bits_[1] & 0x00000010u) != 0; +} +inline void V0LayerParameter::set_has_concat_dim() { + _has_bits_[1] |= 0x00000010u; +} +inline void V0LayerParameter::clear_has_concat_dim() { + _has_bits_[1] &= ~0x00000010u; +} +inline void V0LayerParameter::clear_concat_dim() { + concat_dim_ = 1u; + clear_has_concat_dim(); +} +inline ::google::protobuf::uint32 V0LayerParameter::concat_dim() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.concat_dim) + return concat_dim_; +} +inline void V0LayerParameter::set_concat_dim(::google::protobuf::uint32 value) { + set_has_concat_dim(); + concat_dim_ = value; + // @@protoc_insertion_point(field_set:caffe.V0LayerParameter.concat_dim) +} + +// optional .caffe.HDF5OutputParameter hdf5_output_param = 1001; +inline bool V0LayerParameter::has_hdf5_output_param() const { + return (_has_bits_[1] & 0x00000020u) != 0; +} +inline void V0LayerParameter::set_has_hdf5_output_param() { + _has_bits_[1] |= 0x00000020u; +} +inline void V0LayerParameter::clear_has_hdf5_output_param() { + _has_bits_[1] &= ~0x00000020u; +} +inline void V0LayerParameter::clear_hdf5_output_param() { + if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear(); + clear_has_hdf5_output_param(); +} +inline const ::caffe::HDF5OutputParameter& V0LayerParameter::hdf5_output_param() const { + // @@protoc_insertion_point(field_get:caffe.V0LayerParameter.hdf5_output_param) + return hdf5_output_param_ != NULL ? *hdf5_output_param_ + : *::caffe::HDF5OutputParameter::internal_default_instance(); +} +inline ::caffe::HDF5OutputParameter* V0LayerParameter::mutable_hdf5_output_param() { + set_has_hdf5_output_param(); + if (hdf5_output_param_ == NULL) { + hdf5_output_param_ = new ::caffe::HDF5OutputParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.V0LayerParameter.hdf5_output_param) + return hdf5_output_param_; +} +inline ::caffe::HDF5OutputParameter* V0LayerParameter::release_hdf5_output_param() { + // @@protoc_insertion_point(field_release:caffe.V0LayerParameter.hdf5_output_param) + clear_has_hdf5_output_param(); + ::caffe::HDF5OutputParameter* temp = hdf5_output_param_; + hdf5_output_param_ = NULL; + return temp; +} +inline void V0LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) { + delete hdf5_output_param_; + hdf5_output_param_ = hdf5_output_param; + if (hdf5_output_param) { + set_has_hdf5_output_param(); + } else { + clear_has_hdf5_output_param(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.V0LayerParameter.hdf5_output_param) +} + +inline const V0LayerParameter* V0LayerParameter::internal_default_instance() { + return &V0LayerParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// PReLUParameter + +// optional .caffe.FillerParameter filler = 1; +inline bool PReLUParameter::has_filler() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PReLUParameter::set_has_filler() { + _has_bits_[0] |= 0x00000001u; +} +inline void PReLUParameter::clear_has_filler() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PReLUParameter::clear_filler() { + if (filler_ != NULL) filler_->::caffe::FillerParameter::Clear(); + clear_has_filler(); +} +inline const ::caffe::FillerParameter& PReLUParameter::filler() const { + // @@protoc_insertion_point(field_get:caffe.PReLUParameter.filler) + return filler_ != NULL ? *filler_ + : *::caffe::FillerParameter::internal_default_instance(); +} +inline ::caffe::FillerParameter* PReLUParameter::mutable_filler() { + set_has_filler(); + if (filler_ == NULL) { + filler_ = new ::caffe::FillerParameter; + } + // @@protoc_insertion_point(field_mutable:caffe.PReLUParameter.filler) + return filler_; +} +inline ::caffe::FillerParameter* PReLUParameter::release_filler() { + // @@protoc_insertion_point(field_release:caffe.PReLUParameter.filler) + clear_has_filler(); + ::caffe::FillerParameter* temp = filler_; + filler_ = NULL; + return temp; +} +inline void PReLUParameter::set_allocated_filler(::caffe::FillerParameter* filler) { + delete filler_; + filler_ = filler; + if (filler) { + set_has_filler(); + } else { + clear_has_filler(); + } + // @@protoc_insertion_point(field_set_allocated:caffe.PReLUParameter.filler) +} + +// optional bool channel_shared = 2 [default = false]; +inline bool PReLUParameter::has_channel_shared() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PReLUParameter::set_has_channel_shared() { + _has_bits_[0] |= 0x00000002u; +} +inline void PReLUParameter::clear_has_channel_shared() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PReLUParameter::clear_channel_shared() { + channel_shared_ = false; + clear_has_channel_shared(); +} +inline bool PReLUParameter::channel_shared() const { + // @@protoc_insertion_point(field_get:caffe.PReLUParameter.channel_shared) + return channel_shared_; +} +inline void PReLUParameter::set_channel_shared(bool value) { + set_has_channel_shared(); + channel_shared_ = value; + // @@protoc_insertion_point(field_set:caffe.PReLUParameter.channel_shared) +} + +inline const PReLUParameter* PReLUParameter::internal_default_instance() { + return &PReLUParameter_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NormalizedBBox + +// optional float xmin = 1; +inline bool NormalizedBBox::has_xmin() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void NormalizedBBox::set_has_xmin() { + _has_bits_[0] |= 0x00000001u; +} +inline void NormalizedBBox::clear_has_xmin() { + _has_bits_[0] &= ~0x00000001u; +} +inline void NormalizedBBox::clear_xmin() { + xmin_ = 0; + clear_has_xmin(); +} +inline float NormalizedBBox::xmin() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.xmin) + return xmin_; +} +inline void NormalizedBBox::set_xmin(float value) { + set_has_xmin(); + xmin_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.xmin) +} + +// optional float ymin = 2; +inline bool NormalizedBBox::has_ymin() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void NormalizedBBox::set_has_ymin() { + _has_bits_[0] |= 0x00000002u; +} +inline void NormalizedBBox::clear_has_ymin() { + _has_bits_[0] &= ~0x00000002u; +} +inline void NormalizedBBox::clear_ymin() { + ymin_ = 0; + clear_has_ymin(); +} +inline float NormalizedBBox::ymin() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.ymin) + return ymin_; +} +inline void NormalizedBBox::set_ymin(float value) { + set_has_ymin(); + ymin_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.ymin) +} + +// optional float xmax = 3; +inline bool NormalizedBBox::has_xmax() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void NormalizedBBox::set_has_xmax() { + _has_bits_[0] |= 0x00000004u; +} +inline void NormalizedBBox::clear_has_xmax() { + _has_bits_[0] &= ~0x00000004u; +} +inline void NormalizedBBox::clear_xmax() { + xmax_ = 0; + clear_has_xmax(); +} +inline float NormalizedBBox::xmax() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.xmax) + return xmax_; +} +inline void NormalizedBBox::set_xmax(float value) { + set_has_xmax(); + xmax_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.xmax) +} + +// optional float ymax = 4; +inline bool NormalizedBBox::has_ymax() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void NormalizedBBox::set_has_ymax() { + _has_bits_[0] |= 0x00000008u; +} +inline void NormalizedBBox::clear_has_ymax() { + _has_bits_[0] &= ~0x00000008u; +} +inline void NormalizedBBox::clear_ymax() { + ymax_ = 0; + clear_has_ymax(); +} +inline float NormalizedBBox::ymax() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.ymax) + return ymax_; +} +inline void NormalizedBBox::set_ymax(float value) { + set_has_ymax(); + ymax_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.ymax) +} + +// optional int32 label = 5; +inline bool NormalizedBBox::has_label() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void NormalizedBBox::set_has_label() { + _has_bits_[0] |= 0x00000010u; +} +inline void NormalizedBBox::clear_has_label() { + _has_bits_[0] &= ~0x00000010u; +} +inline void NormalizedBBox::clear_label() { + label_ = 0; + clear_has_label(); +} +inline ::google::protobuf::int32 NormalizedBBox::label() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.label) + return label_; +} +inline void NormalizedBBox::set_label(::google::protobuf::int32 value) { + set_has_label(); + label_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.label) +} + +// optional bool difficult = 6; +inline bool NormalizedBBox::has_difficult() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void NormalizedBBox::set_has_difficult() { + _has_bits_[0] |= 0x00000020u; +} +inline void NormalizedBBox::clear_has_difficult() { + _has_bits_[0] &= ~0x00000020u; +} +inline void NormalizedBBox::clear_difficult() { + difficult_ = false; + clear_has_difficult(); +} +inline bool NormalizedBBox::difficult() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.difficult) + return difficult_; +} +inline void NormalizedBBox::set_difficult(bool value) { + set_has_difficult(); + difficult_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.difficult) +} + +// optional float score = 7; +inline bool NormalizedBBox::has_score() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void NormalizedBBox::set_has_score() { + _has_bits_[0] |= 0x00000040u; +} +inline void NormalizedBBox::clear_has_score() { + _has_bits_[0] &= ~0x00000040u; +} +inline void NormalizedBBox::clear_score() { + score_ = 0; + clear_has_score(); +} +inline float NormalizedBBox::score() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.score) + return score_; +} +inline void NormalizedBBox::set_score(float value) { + set_has_score(); + score_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.score) +} + +// optional float size = 8; +inline bool NormalizedBBox::has_size() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void NormalizedBBox::set_has_size() { + _has_bits_[0] |= 0x00000080u; +} +inline void NormalizedBBox::clear_has_size() { + _has_bits_[0] &= ~0x00000080u; +} +inline void NormalizedBBox::clear_size() { + size_ = 0; + clear_has_size(); +} +inline float NormalizedBBox::size() const { + // @@protoc_insertion_point(field_get:caffe.NormalizedBBox.size) + return size_; +} +inline void NormalizedBBox::set_size(float value) { + set_has_size(); + size_ = value; + // @@protoc_insertion_point(field_set:caffe.NormalizedBBox.size) +} + +inline const NormalizedBBox* NormalizedBBox::internal_default_instance() { + return &NormalizedBBox_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace caffe + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::caffe::PriorBoxParameter_CodeType> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PriorBoxParameter_CodeType>() { + return ::caffe::PriorBoxParameter_CodeType_descriptor(); +} +template <> struct is_proto_enum< ::caffe::FillerParameter_VarianceNorm> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::FillerParameter_VarianceNorm>() { + return ::caffe::FillerParameter_VarianceNorm_descriptor(); +} +template <> struct is_proto_enum< ::caffe::SolverParameter_SnapshotFormat> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SnapshotFormat>() { + return ::caffe::SolverParameter_SnapshotFormat_descriptor(); +} +template <> struct is_proto_enum< ::caffe::SolverParameter_SolverMode> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SolverMode>() { + return ::caffe::SolverParameter_SolverMode_descriptor(); +} +template <> struct is_proto_enum< ::caffe::SolverParameter_SolverType> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SolverType>() { + return ::caffe::SolverParameter_SolverType_descriptor(); +} +template <> struct is_proto_enum< ::caffe::ParamSpec_DimCheckMode> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ParamSpec_DimCheckMode>() { + return ::caffe::ParamSpec_DimCheckMode_descriptor(); +} +template <> struct is_proto_enum< ::caffe::LossParameter_NormalizationMode> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LossParameter_NormalizationMode>() { + return ::caffe::LossParameter_NormalizationMode_descriptor(); +} +template <> struct is_proto_enum< ::caffe::ConvolutionParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ConvolutionParameter_Engine>() { + return ::caffe::ConvolutionParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::DataParameter_DB> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::DataParameter_DB>() { + return ::caffe::DataParameter_DB_descriptor(); +} +template <> struct is_proto_enum< ::caffe::EltwiseParameter_EltwiseOp> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::EltwiseParameter_EltwiseOp>() { + return ::caffe::EltwiseParameter_EltwiseOp_descriptor(); +} +template <> struct is_proto_enum< ::caffe::HingeLossParameter_Norm> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::HingeLossParameter_Norm>() { + return ::caffe::HingeLossParameter_Norm_descriptor(); +} +template <> struct is_proto_enum< ::caffe::LRNParameter_NormRegion> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LRNParameter_NormRegion>() { + return ::caffe::LRNParameter_NormRegion_descriptor(); +} +template <> struct is_proto_enum< ::caffe::LRNParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LRNParameter_Engine>() { + return ::caffe::LRNParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::PoolingParameter_PoolMethod> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PoolingParameter_PoolMethod>() { + return ::caffe::PoolingParameter_PoolMethod_descriptor(); +} +template <> struct is_proto_enum< ::caffe::PoolingParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PoolingParameter_Engine>() { + return ::caffe::PoolingParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::ReductionParameter_ReductionOp> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ReductionParameter_ReductionOp>() { + return ::caffe::ReductionParameter_ReductionOp_descriptor(); +} +template <> struct is_proto_enum< ::caffe::ReLUParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ReLUParameter_Engine>() { + return ::caffe::ReLUParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::SigmoidParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SigmoidParameter_Engine>() { + return ::caffe::SigmoidParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::SoftmaxParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SoftmaxParameter_Engine>() { + return ::caffe::SoftmaxParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::TanHParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::TanHParameter_Engine>() { + return ::caffe::TanHParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::SPPParameter_PoolMethod> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SPPParameter_PoolMethod>() { + return ::caffe::SPPParameter_PoolMethod_descriptor(); +} +template <> struct is_proto_enum< ::caffe::SPPParameter_Engine> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SPPParameter_Engine>() { + return ::caffe::SPPParameter_Engine_descriptor(); +} +template <> struct is_proto_enum< ::caffe::V1LayerParameter_LayerType> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::V1LayerParameter_LayerType>() { + return ::caffe::V1LayerParameter_LayerType_descriptor(); +} +template <> struct is_proto_enum< ::caffe::V1LayerParameter_DimCheckMode> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::V1LayerParameter_DimCheckMode>() { + return ::caffe::V1LayerParameter_DimCheckMode_descriptor(); +} +template <> struct is_proto_enum< ::caffe::V0LayerParameter_PoolMethod> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::V0LayerParameter_PoolMethod>() { + return ::caffe::V0LayerParameter_PoolMethod_descriptor(); +} +template <> struct is_proto_enum< ::caffe::Phase> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::caffe::Phase>() { + return ::caffe::Phase_descriptor(); +} + +} // namespace protobuf +} // namespace google +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_caffe_2eproto__INCLUDED diff --git a/modules/dnn/misc/python/pyopencv_dnn.hpp b/modules/dnn/misc/python/pyopencv_dnn.hpp new file mode 100644 index 0000000000..312e5fcc56 --- /dev/null +++ b/modules/dnn/misc/python/pyopencv_dnn.hpp @@ -0,0 +1,39 @@ +#ifdef HAVE_OPENCV_DNN +typedef dnn::DictValue LayerId; +typedef std::vector vector_MatShape; +typedef std::vector > vector_vector_MatShape; +typedef std::vector vector_size_t; +typedef std::vector > vector_vector_Mat; + +template<> +bool pyopencv_to(PyObject *o, dnn::DictValue &dv, const char *name) +{ + (void)name; + if (!o || o == Py_None) + return true; //Current state will be used + else if (PyLong_Check(o)) + { + dv = dnn::DictValue((int64)PyLong_AsLongLong(o)); + return true; + } + else if (PyFloat_Check(o)) + { + dv = dnn::DictValue(PyFloat_AS_DOUBLE(o)); + return true; + } + else if (PyString_Check(o)) + { + dv = dnn::DictValue(String(PyString_AsString(o))); + return true; + } + else + return false; +} + +template<> +bool pyopencv_to(PyObject *o, std::vector &blobs, const char *name) //required for Layer::blobs RW +{ + return pyopencvVecConverter::to(o, blobs, ArgInfo(name, false)); +} + +#endif diff --git a/modules/dnn/misc/tensorflow/attr_value.pb.cc b/modules/dnn/misc/tensorflow/attr_value.pb.cc new file mode 100644 index 0000000000..deb3320e14 --- /dev/null +++ b/modules/dnn/misc/tensorflow/attr_value.pb.cc @@ -0,0 +1,3014 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: attr_value.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "attr_value.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::Descriptor* AttrValue_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AttrValue_reflection_ = NULL; +struct AttrValueOneofInstance { + ::google::protobuf::internal::ArenaStringPtr s_; + ::google::protobuf::int64 i_; + float f_; + bool b_; + int type_; + const ::tensorflow::TensorShapeProto* shape_; + const ::tensorflow::TensorProto* tensor_; + const ::tensorflow::AttrValue_ListValue* list_; + const ::tensorflow::NameAttrList* func_; + ::google::protobuf::internal::ArenaStringPtr placeholder_; +}* AttrValue_default_oneof_instance_ = NULL; +const ::google::protobuf::Descriptor* AttrValue_ListValue_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AttrValue_ListValue_reflection_ = NULL; +const ::google::protobuf::Descriptor* NameAttrList_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NameAttrList_reflection_ = NULL; +const ::google::protobuf::Descriptor* NameAttrList_AttrEntry_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_attr_5fvalue_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_attr_5fvalue_2eproto() { + protobuf_AddDesc_attr_5fvalue_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "attr_value.proto"); + GOOGLE_CHECK(file != NULL); + AttrValue_descriptor_ = file->message_type(0); + static const int AttrValue_offsets_[11] = { + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, s_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, i_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, f_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, b_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, type_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, shape_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, tensor_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, list_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, func_), + PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(AttrValue_default_oneof_instance_, placeholder_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue, value_), + }; + AttrValue_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + AttrValue_descriptor_, + AttrValue::internal_default_instance(), + AttrValue_offsets_, + -1, + -1, + -1, + AttrValue_default_oneof_instance_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue, _oneof_case_[0]), + sizeof(AttrValue), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue, _internal_metadata_)); + AttrValue_ListValue_descriptor_ = AttrValue_descriptor_->nested_type(0); + static const int AttrValue_ListValue_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, i_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, f_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, b_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, shape_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, tensor_), + }; + AttrValue_ListValue_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + AttrValue_ListValue_descriptor_, + AttrValue_ListValue::internal_default_instance(), + AttrValue_ListValue_offsets_, + -1, + -1, + -1, + sizeof(AttrValue_ListValue), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttrValue_ListValue, _internal_metadata_)); + NameAttrList_descriptor_ = file->message_type(1); + static const int NameAttrList_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NameAttrList, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NameAttrList, attr_), + }; + NameAttrList_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NameAttrList_descriptor_, + NameAttrList::internal_default_instance(), + NameAttrList_offsets_, + -1, + -1, + -1, + sizeof(NameAttrList), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NameAttrList, _internal_metadata_)); + NameAttrList_AttrEntry_descriptor_ = NameAttrList_descriptor_->nested_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_attr_5fvalue_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AttrValue_descriptor_, AttrValue::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AttrValue_ListValue_descriptor_, AttrValue_ListValue::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NameAttrList_descriptor_, NameAttrList::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NameAttrList_AttrEntry_descriptor_, + ::google::protobuf::internal::MapEntry< + ::std::string, + ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0>::CreateDefaultInstance( + NameAttrList_AttrEntry_descriptor_)); +} + +} // namespace + +void protobuf_ShutdownFile_attr_5fvalue_2eproto() { + AttrValue_default_instance_.Shutdown(); + delete AttrValue_default_oneof_instance_; + delete AttrValue_reflection_; + AttrValue_ListValue_default_instance_.Shutdown(); + delete AttrValue_ListValue_reflection_; + NameAttrList_default_instance_.Shutdown(); + delete NameAttrList_reflection_; +} + +void protobuf_InitDefaults_attr_5fvalue_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::tensorflow::protobuf_InitDefaults_tensor_2eproto(); + ::tensorflow::protobuf_InitDefaults_tensor_5fshape_2eproto(); + ::tensorflow::protobuf_InitDefaults_types_2eproto(); + ::google::protobuf::internal::GetEmptyString(); + AttrValue_default_instance_.DefaultConstruct(); + AttrValue_default_oneof_instance_ = new AttrValueOneofInstance(); + ::google::protobuf::internal::GetEmptyString(); + AttrValue_ListValue_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + NameAttrList_default_instance_.DefaultConstruct(); + AttrValue_default_instance_.get_mutable()->InitAsDefaultInstance(); + AttrValue_ListValue_default_instance_.get_mutable()->InitAsDefaultInstance(); + NameAttrList_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_attr_5fvalue_2eproto_once_); +void protobuf_InitDefaults_attr_5fvalue_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_attr_5fvalue_2eproto_once_, + &protobuf_InitDefaults_attr_5fvalue_2eproto_impl); +} +void protobuf_AddDesc_attr_5fvalue_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_attr_5fvalue_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\020attr_value.proto\022\ntensorflow\032\014tensor.p" + "roto\032\022tensor_shape.proto\032\013types.proto\"\376\003" + "\n\tAttrValue\022\013\n\001s\030\002 \001(\014H\000\022\013\n\001i\030\003 \001(\003H\000\022\013\n" + "\001f\030\004 \001(\002H\000\022\013\n\001b\030\005 \001(\010H\000\022$\n\004type\030\006 \001(\0162\024." + "tensorflow.DataTypeH\000\022-\n\005shape\030\007 \001(\0132\034.t" + "ensorflow.TensorShapeProtoH\000\022)\n\006tensor\030\010" + " \001(\0132\027.tensorflow.TensorProtoH\000\022/\n\004list\030" + "\001 \001(\0132\037.tensorflow.AttrValue.ListValueH\000" + "\022(\n\004func\030\n \001(\0132\030.tensorflow.NameAttrList" + "H\000\022\025\n\013placeholder\030\t \001(\tH\000\032\301\001\n\tListValue\022" + "\t\n\001s\030\002 \003(\014\022\r\n\001i\030\003 \003(\003B\002\020\001\022\r\n\001f\030\004 \003(\002B\002\020\001" + "\022\r\n\001b\030\005 \003(\010B\002\020\001\022&\n\004type\030\006 \003(\0162\024.tensorfl" + "ow.DataTypeB\002\020\001\022+\n\005shape\030\007 \003(\0132\034.tensorf" + "low.TensorShapeProto\022\'\n\006tensor\030\010 \003(\0132\027.t" + "ensorflow.TensorProtoB\007\n\005value\"\222\001\n\014NameA" + "ttrList\022\014\n\004name\030\001 \001(\t\0220\n\004attr\030\002 \003(\0132\".te" + "nsorflow.NameAttrList.AttrEntry\032B\n\tAttrE" + "ntry\022\013\n\003key\030\001 \001(\t\022$\n\005value\030\002 \001(\0132\025.tenso" + "rflow.AttrValue:\0028\001B0\n\030org.tensorflow.fr" + "ameworkB\017AttrValueProtosP\001\370\001\001b\006proto3", 797); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "attr_value.proto", &protobuf_RegisterTypes); + ::tensorflow::protobuf_AddDesc_tensor_2eproto(); + ::tensorflow::protobuf_AddDesc_tensor_5fshape_2eproto(); + ::tensorflow::protobuf_AddDesc_types_2eproto(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_attr_5fvalue_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_attr_5fvalue_2eproto_once_); +void protobuf_AddDesc_attr_5fvalue_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_attr_5fvalue_2eproto_once_, + &protobuf_AddDesc_attr_5fvalue_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_attr_5fvalue_2eproto { + StaticDescriptorInitializer_attr_5fvalue_2eproto() { + protobuf_AddDesc_attr_5fvalue_2eproto(); + } +} static_descriptor_initializer_attr_5fvalue_2eproto_; + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int AttrValue_ListValue::kSFieldNumber; +const int AttrValue_ListValue::kIFieldNumber; +const int AttrValue_ListValue::kFFieldNumber; +const int AttrValue_ListValue::kBFieldNumber; +const int AttrValue_ListValue::kTypeFieldNumber; +const int AttrValue_ListValue::kShapeFieldNumber; +const int AttrValue_ListValue::kTensorFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +AttrValue_ListValue::AttrValue_ListValue() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_attr_5fvalue_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.AttrValue.ListValue) +} +AttrValue_ListValue::AttrValue_ListValue(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + s_(arena), + i_(arena), + f_(arena), + b_(arena), + type_(arena), + shape_(arena), + tensor_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_attr_5fvalue_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.AttrValue.ListValue) +} + +void AttrValue_ListValue::InitAsDefaultInstance() { +} + +AttrValue_ListValue::AttrValue_ListValue(const AttrValue_ListValue& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.AttrValue.ListValue) +} + +void AttrValue_ListValue::SharedCtor() { + _cached_size_ = 0; +} + +AttrValue_ListValue::~AttrValue_ListValue() { + // @@protoc_insertion_point(destructor:tensorflow.AttrValue.ListValue) + SharedDtor(); +} + +void AttrValue_ListValue::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + +} + +void AttrValue_ListValue::ArenaDtor(void* object) { + AttrValue_ListValue* _this = reinterpret_cast< AttrValue_ListValue* >(object); + (void)_this; +} +void AttrValue_ListValue::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void AttrValue_ListValue::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AttrValue_ListValue::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AttrValue_ListValue_descriptor_; +} + +const AttrValue_ListValue& AttrValue_ListValue::default_instance() { + protobuf_InitDefaults_attr_5fvalue_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed AttrValue_ListValue_default_instance_; + +AttrValue_ListValue* AttrValue_ListValue::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void AttrValue_ListValue::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.AttrValue.ListValue) + s_.Clear(); + i_.Clear(); + f_.Clear(); + b_.Clear(); + type_.Clear(); + shape_.Clear(); + tensor_.Clear(); +} + +bool AttrValue_ListValue::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.AttrValue.ListValue) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated bytes s = 2; + case 2: { + if (tag == 18) { + parse_s: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->add_s())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_s; + if (input->ExpectTag(26)) goto parse_i; + break; + } + + // repeated int64 i = 3 [packed = true]; + case 3: { + if (tag == 26) { + parse_i: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_i()))); + } else if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + 1, 26, input, this->mutable_i()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_f; + break; + } + + // repeated float f = 4 [packed = true]; + case 4: { + if (tag == 34) { + parse_f: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_f()))); + } else if (tag == 37) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 34, input, this->mutable_f()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_b; + break; + } + + // repeated bool b = 5 [packed = true]; + case 5: { + if (tag == 42) { + parse_b: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, this->mutable_b()))); + } else if (tag == 40) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + 1, 42, input, this->mutable_b()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_type; + break; + } + + // repeated .tensorflow.DataType type = 6 [packed = true]; + case 6: { + if (tag == 50) { + parse_type: + ::google::protobuf::uint32 length; + DO_(input->ReadVarint32(&length)); + ::google::protobuf::io::CodedInputStream::Limit limit = input->PushLimit(length); + while (input->BytesUntilLimit() > 0) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + add_type(static_cast< ::tensorflow::DataType >(value)); + } + input->PopLimit(limit); + } else if (tag == 48) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + add_type(static_cast< ::tensorflow::DataType >(value)); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_shape; + break; + } + + // repeated .tensorflow.TensorShapeProto shape = 7; + case 7: { + if (tag == 58) { + parse_shape: + DO_(input->IncrementRecursionDepth()); + parse_loop_shape: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_loop_shape; + if (input->ExpectTag(66)) goto parse_loop_tensor; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .tensorflow.TensorProto tensor = 8; + case 8: { + if (tag == 66) { + DO_(input->IncrementRecursionDepth()); + parse_loop_tensor: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_tensor())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_loop_tensor; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.AttrValue.ListValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.AttrValue.ListValue) + return false; +#undef DO_ +} + +void AttrValue_ListValue::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.AttrValue.ListValue) + // repeated bytes s = 2; + for (int i = 0; i < this->s_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 2, this->s(i), output); + } + + // repeated int64 i = 3 [packed = true]; + if (this->i_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_i_cached_byte_size_); + } + for (int i = 0; i < this->i_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt64NoTag( + this->i(i), output); + } + + // repeated float f = 4 [packed = true]; + if (this->f_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_f_cached_byte_size_); + } + for (int i = 0; i < this->f_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloatNoTag( + this->f(i), output); + } + + // repeated bool b = 5 [packed = true]; + if (this->b_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_b_cached_byte_size_); + } + for (int i = 0; i < this->b_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteBoolNoTag( + this->b(i), output); + } + + // repeated .tensorflow.DataType type = 6 [packed = true]; + if (this->type_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag( + 6, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + output); + output->WriteVarint32(_type_cached_byte_size_); + } + for (int i = 0; i < this->type_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnumNoTag( + this->type(i), output); + } + + // repeated .tensorflow.TensorShapeProto shape = 7; + for (unsigned int i = 0, n = this->shape_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->shape(i), output); + } + + // repeated .tensorflow.TensorProto tensor = 8; + for (unsigned int i = 0, n = this->tensor_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->tensor(i), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.AttrValue.ListValue) +} + +::google::protobuf::uint8* AttrValue_ListValue::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.AttrValue.ListValue) + // repeated bytes s = 2; + for (int i = 0; i < this->s_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBytesToArray(2, this->s(i), target); + } + + // repeated int64 i = 3 [packed = true]; + if (this->i_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 3, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _i_cached_byte_size_, target); + } + for (int i = 0; i < this->i_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->i(i), target); + } + + // repeated float f = 4 [packed = true]; + if (this->f_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 4, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _f_cached_byte_size_, target); + } + for (int i = 0; i < this->f_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->f(i), target); + } + + // repeated bool b = 5 [packed = true]; + if (this->b_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 5, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _b_cached_byte_size_, target); + } + for (int i = 0; i < this->b_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBoolNoTagToArray(this->b(i), target); + } + + // repeated .tensorflow.DataType type = 6 [packed = true]; + if (this->type_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 6, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( _type_cached_byte_size_, target); + } + for (int i = 0; i < this->type_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumNoTagToArray( + this->type(i), target); + } + + // repeated .tensorflow.TensorShapeProto shape = 7; + for (unsigned int i = 0, n = this->shape_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 7, this->shape(i), false, target); + } + + // repeated .tensorflow.TensorProto tensor = 8; + for (unsigned int i = 0, n = this->tensor_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 8, this->tensor(i), false, target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.AttrValue.ListValue) + return target; +} + +size_t AttrValue_ListValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.AttrValue.ListValue) + size_t total_size = 0; + + // repeated bytes s = 2; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->s_size()); + for (int i = 0; i < this->s_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( + this->s(i)); + } + + // repeated int64 i = 3 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->i_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int64Size(this->i(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _i_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated float f = 4 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->f_size(); + data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _f_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated bool b = 5 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->b_size(); + data_size = 1UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _b_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated .tensorflow.DataType type = 6 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->type_size();for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->type(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _type_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated .tensorflow.TensorShapeProto shape = 7; + { + unsigned int count = this->shape_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->shape(i)); + } + } + + // repeated .tensorflow.TensorProto tensor = 8; + { + unsigned int count = this->tensor_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->tensor(i)); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AttrValue_ListValue::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.AttrValue.ListValue) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const AttrValue_ListValue* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.AttrValue.ListValue) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.AttrValue.ListValue) + UnsafeMergeFrom(*source); + } +} + +void AttrValue_ListValue::MergeFrom(const AttrValue_ListValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.AttrValue.ListValue) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void AttrValue_ListValue::UnsafeMergeFrom(const AttrValue_ListValue& from) { + GOOGLE_DCHECK(&from != this); + s_.UnsafeMergeFrom(from.s_); + i_.UnsafeMergeFrom(from.i_); + f_.UnsafeMergeFrom(from.f_); + b_.UnsafeMergeFrom(from.b_); + type_.UnsafeMergeFrom(from.type_); + shape_.MergeFrom(from.shape_); + tensor_.MergeFrom(from.tensor_); +} + +void AttrValue_ListValue::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.AttrValue.ListValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttrValue_ListValue::CopyFrom(const AttrValue_ListValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.AttrValue.ListValue) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool AttrValue_ListValue::IsInitialized() const { + + return true; +} + +void AttrValue_ListValue::Swap(AttrValue_ListValue* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + AttrValue_ListValue temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void AttrValue_ListValue::UnsafeArenaSwap(AttrValue_ListValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void AttrValue_ListValue::InternalSwap(AttrValue_ListValue* other) { + s_.UnsafeArenaSwap(&other->s_); + i_.UnsafeArenaSwap(&other->i_); + f_.UnsafeArenaSwap(&other->f_); + b_.UnsafeArenaSwap(&other->b_); + type_.UnsafeArenaSwap(&other->type_); + shape_.UnsafeArenaSwap(&other->shape_); + tensor_.UnsafeArenaSwap(&other->tensor_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata AttrValue_ListValue::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AttrValue_ListValue_descriptor_; + metadata.reflection = AttrValue_ListValue_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int AttrValue::kSFieldNumber; +const int AttrValue::kIFieldNumber; +const int AttrValue::kFFieldNumber; +const int AttrValue::kBFieldNumber; +const int AttrValue::kTypeFieldNumber; +const int AttrValue::kShapeFieldNumber; +const int AttrValue::kTensorFieldNumber; +const int AttrValue::kListFieldNumber; +const int AttrValue::kFuncFieldNumber; +const int AttrValue::kPlaceholderFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +AttrValue::AttrValue() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_attr_5fvalue_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.AttrValue) +} +AttrValue::AttrValue(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_attr_5fvalue_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.AttrValue) +} + +void AttrValue::InitAsDefaultInstance() { + AttrValue_default_oneof_instance_->s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + AttrValue_default_oneof_instance_->i_ = GOOGLE_LONGLONG(0); + AttrValue_default_oneof_instance_->f_ = 0; + AttrValue_default_oneof_instance_->b_ = false; + AttrValue_default_oneof_instance_->type_ = 0; + AttrValue_default_oneof_instance_->shape_ = const_cast< ::tensorflow::TensorShapeProto*>( + ::tensorflow::TensorShapeProto::internal_default_instance()); + AttrValue_default_oneof_instance_->tensor_ = const_cast< ::tensorflow::TensorProto*>( + ::tensorflow::TensorProto::internal_default_instance()); + AttrValue_default_oneof_instance_->list_ = const_cast< ::tensorflow::AttrValue_ListValue*>( + ::tensorflow::AttrValue_ListValue::internal_default_instance()); + AttrValue_default_oneof_instance_->func_ = const_cast< ::tensorflow::NameAttrList*>( + ::tensorflow::NameAttrList::internal_default_instance()); + AttrValue_default_oneof_instance_->placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +AttrValue::AttrValue(const AttrValue& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.AttrValue) +} + +void AttrValue::SharedCtor() { + clear_has_value(); + _cached_size_ = 0; +} + +AttrValue::~AttrValue() { + // @@protoc_insertion_point(destructor:tensorflow.AttrValue) + SharedDtor(); +} + +void AttrValue::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + if (has_value()) { + clear_value(); + } +} + +void AttrValue::ArenaDtor(void* object) { + AttrValue* _this = reinterpret_cast< AttrValue* >(object); + (void)_this; +} +void AttrValue::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void AttrValue::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AttrValue::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AttrValue_descriptor_; +} + +const AttrValue& AttrValue::default_instance() { + protobuf_InitDefaults_attr_5fvalue_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed AttrValue_default_instance_; + +AttrValue* AttrValue::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void AttrValue::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:tensorflow.AttrValue) + switch (value_case()) { + case kS: { + value_.s_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + break; + } + case kI: { + // No need to clear + break; + } + case kF: { + // No need to clear + break; + } + case kB: { + // No need to clear + break; + } + case kType: { + // No need to clear + break; + } + case kShape: { + if (GetArenaNoVirtual() == NULL) { + delete value_.shape_; + } + break; + } + case kTensor: { + if (GetArenaNoVirtual() == NULL) { + delete value_.tensor_; + } + break; + } + case kList: { + if (GetArenaNoVirtual() == NULL) { + delete value_.list_; + } + break; + } + case kFunc: { + if (GetArenaNoVirtual() == NULL) { + delete value_.func_; + } + break; + } + case kPlaceholder: { + value_.placeholder_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void AttrValue::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.AttrValue) + clear_value(); +} + +bool AttrValue::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.AttrValue) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .tensorflow.AttrValue.ListValue list = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_list())); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional bytes s = 2; + case 2: { + if (tag == 18) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_s())); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional int64 i = 3; + case 3: { + if (tag == 24) { + clear_value(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &value_.i_))); + set_has_i(); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional float f = 4; + case 4: { + if (tag == 37) { + clear_value(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &value_.f_))); + set_has_f(); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional bool b = 5; + case 5: { + if (tag == 40) { + clear_value(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &value_.b_))); + set_has_b(); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional .tensorflow.DataType type = 6; + case 6: { + if (tag == 48) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_type(static_cast< ::tensorflow::DataType >(value)); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional .tensorflow.TensorShapeProto shape = 7; + case 7: { + if (tag == 58) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_shape())); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional .tensorflow.TensorProto tensor = 8; + case 8: { + if (tag == 66) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tensor())); + } else { + goto handle_unusual; + } + goto after_func; + break; + } + + // optional string placeholder = 9; + case 9: { + if (tag == 74) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_placeholder())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->placeholder().data(), this->placeholder().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.AttrValue.placeholder")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_func; + break; + } + + // optional .tensorflow.NameAttrList func = 10; + case 10: { + if (tag == 82) { + parse_func: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_func())); + } else { + goto handle_unusual; + } + after_func: + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.AttrValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.AttrValue) + return false; +#undef DO_ +} + +void AttrValue::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.AttrValue) + // optional .tensorflow.AttrValue.ListValue list = 1; + if (has_list()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, *value_.list_, output); + } + + // optional bytes s = 2; + if (has_s()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->s(), output); + } + + // optional int64 i = 3; + if (has_i()) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->i(), output); + } + + // optional float f = 4; + if (has_f()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->f(), output); + } + + // optional bool b = 5; + if (has_b()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->b(), output); + } + + // optional .tensorflow.DataType type = 6; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->type(), output); + } + + // optional .tensorflow.TensorShapeProto shape = 7; + if (has_shape()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, *value_.shape_, output); + } + + // optional .tensorflow.TensorProto tensor = 8; + if (has_tensor()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, *value_.tensor_, output); + } + + // optional string placeholder = 9; + if (has_placeholder()) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->placeholder().data(), this->placeholder().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.AttrValue.placeholder"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 9, this->placeholder(), output); + } + + // optional .tensorflow.NameAttrList func = 10; + if (has_func()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, *value_.func_, output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.AttrValue) +} + +::google::protobuf::uint8* AttrValue::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.AttrValue) + // optional .tensorflow.AttrValue.ListValue list = 1; + if (has_list()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, *value_.list_, false, target); + } + + // optional bytes s = 2; + if (has_s()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->s(), target); + } + + // optional int64 i = 3; + if (has_i()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->i(), target); + } + + // optional float f = 4; + if (has_f()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->f(), target); + } + + // optional bool b = 5; + if (has_b()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->b(), target); + } + + // optional .tensorflow.DataType type = 6; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->type(), target); + } + + // optional .tensorflow.TensorShapeProto shape = 7; + if (has_shape()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 7, *value_.shape_, false, target); + } + + // optional .tensorflow.TensorProto tensor = 8; + if (has_tensor()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 8, *value_.tensor_, false, target); + } + + // optional string placeholder = 9; + if (has_placeholder()) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->placeholder().data(), this->placeholder().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.AttrValue.placeholder"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 9, this->placeholder(), target); + } + + // optional .tensorflow.NameAttrList func = 10; + if (has_func()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 10, *value_.func_, false, target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.AttrValue) + return target; +} + +size_t AttrValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.AttrValue) + size_t total_size = 0; + + switch (value_case()) { + // optional bytes s = 2; + case kS: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->s()); + break; + } + // optional int64 i = 3; + case kI: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->i()); + break; + } + // optional float f = 4; + case kF: { + total_size += 1 + 4; + break; + } + // optional bool b = 5; + case kB: { + total_size += 1 + 1; + break; + } + // optional .tensorflow.DataType type = 6; + case kType: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + break; + } + // optional .tensorflow.TensorShapeProto shape = 7; + case kShape: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *value_.shape_); + break; + } + // optional .tensorflow.TensorProto tensor = 8; + case kTensor: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *value_.tensor_); + break; + } + // optional .tensorflow.AttrValue.ListValue list = 1; + case kList: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *value_.list_); + break; + } + // optional .tensorflow.NameAttrList func = 10; + case kFunc: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *value_.func_); + break; + } + // optional string placeholder = 9; + case kPlaceholder: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->placeholder()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AttrValue::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.AttrValue) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const AttrValue* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.AttrValue) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.AttrValue) + UnsafeMergeFrom(*source); + } +} + +void AttrValue::MergeFrom(const AttrValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.AttrValue) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void AttrValue::UnsafeMergeFrom(const AttrValue& from) { + GOOGLE_DCHECK(&from != this); + switch (from.value_case()) { + case kS: { + set_s(from.s()); + break; + } + case kI: { + set_i(from.i()); + break; + } + case kF: { + set_f(from.f()); + break; + } + case kB: { + set_b(from.b()); + break; + } + case kType: { + set_type(from.type()); + break; + } + case kShape: { + mutable_shape()->::tensorflow::TensorShapeProto::MergeFrom(from.shape()); + break; + } + case kTensor: { + mutable_tensor()->::tensorflow::TensorProto::MergeFrom(from.tensor()); + break; + } + case kList: { + mutable_list()->::tensorflow::AttrValue_ListValue::MergeFrom(from.list()); + break; + } + case kFunc: { + mutable_func()->::tensorflow::NameAttrList::MergeFrom(from.func()); + break; + } + case kPlaceholder: { + set_placeholder(from.placeholder()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void AttrValue::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.AttrValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttrValue::CopyFrom(const AttrValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.AttrValue) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool AttrValue::IsInitialized() const { + + return true; +} + +void AttrValue::Swap(AttrValue* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + AttrValue temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void AttrValue::UnsafeArenaSwap(AttrValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void AttrValue::InternalSwap(AttrValue* other) { + std::swap(value_, other->value_); + std::swap(_oneof_case_[0], other->_oneof_case_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata AttrValue::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AttrValue_descriptor_; + metadata.reflection = AttrValue_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// AttrValue_ListValue + +// repeated bytes s = 2; +int AttrValue_ListValue::s_size() const { + return s_.size(); +} +void AttrValue_ListValue::clear_s() { + s_.Clear(); +} +const ::std::string& AttrValue_ListValue::s(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.s) + return s_.Get(index); +} +::std::string* AttrValue_ListValue::mutable_s(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.s) + return s_.Mutable(index); +} +void AttrValue_ListValue::set_s(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.s) + s_.Mutable(index)->assign(value); +} +void AttrValue_ListValue::set_s(int index, const char* value) { + s_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.AttrValue.ListValue.s) +} +void AttrValue_ListValue::set_s(int index, const void* value, size_t size) { + s_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.AttrValue.ListValue.s) +} +::std::string* AttrValue_ListValue::add_s() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.AttrValue.ListValue.s) + return s_.Add(); +} +void AttrValue_ListValue::add_s(const ::std::string& value) { + s_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.s) +} +void AttrValue_ListValue::add_s(const char* value) { + s_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.AttrValue.ListValue.s) +} +void AttrValue_ListValue::add_s(const void* value, size_t size) { + s_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.AttrValue.ListValue.s) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +AttrValue_ListValue::s() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.s) + return s_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +AttrValue_ListValue::mutable_s() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.s) + return &s_; +} + +// repeated int64 i = 3 [packed = true]; +int AttrValue_ListValue::i_size() const { + return i_.size(); +} +void AttrValue_ListValue::clear_i() { + i_.Clear(); +} +::google::protobuf::int64 AttrValue_ListValue::i(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.i) + return i_.Get(index); +} +void AttrValue_ListValue::set_i(int index, ::google::protobuf::int64 value) { + i_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.i) +} +void AttrValue_ListValue::add_i(::google::protobuf::int64 value) { + i_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.i) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& +AttrValue_ListValue::i() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.i) + return i_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int64 >* +AttrValue_ListValue::mutable_i() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.i) + return &i_; +} + +// repeated float f = 4 [packed = true]; +int AttrValue_ListValue::f_size() const { + return f_.size(); +} +void AttrValue_ListValue::clear_f() { + f_.Clear(); +} +float AttrValue_ListValue::f(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.f) + return f_.Get(index); +} +void AttrValue_ListValue::set_f(int index, float value) { + f_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.f) +} +void AttrValue_ListValue::add_f(float value) { + f_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.f) +} +const ::google::protobuf::RepeatedField< float >& +AttrValue_ListValue::f() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.f) + return f_; +} +::google::protobuf::RepeatedField< float >* +AttrValue_ListValue::mutable_f() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.f) + return &f_; +} + +// repeated bool b = 5 [packed = true]; +int AttrValue_ListValue::b_size() const { + return b_.size(); +} +void AttrValue_ListValue::clear_b() { + b_.Clear(); +} +bool AttrValue_ListValue::b(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.b) + return b_.Get(index); +} +void AttrValue_ListValue::set_b(int index, bool value) { + b_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.b) +} +void AttrValue_ListValue::add_b(bool value) { + b_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.b) +} +const ::google::protobuf::RepeatedField< bool >& +AttrValue_ListValue::b() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.b) + return b_; +} +::google::protobuf::RepeatedField< bool >* +AttrValue_ListValue::mutable_b() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.b) + return &b_; +} + +// repeated .tensorflow.DataType type = 6 [packed = true]; +int AttrValue_ListValue::type_size() const { + return type_.size(); +} +void AttrValue_ListValue::clear_type() { + type_.Clear(); +} +::tensorflow::DataType AttrValue_ListValue::type(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.type) + return static_cast< ::tensorflow::DataType >(type_.Get(index)); +} +void AttrValue_ListValue::set_type(int index, ::tensorflow::DataType value) { + type_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.type) +} +void AttrValue_ListValue::add_type(::tensorflow::DataType value) { + type_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.type) +} +const ::google::protobuf::RepeatedField& +AttrValue_ListValue::type() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.type) + return type_; +} +::google::protobuf::RepeatedField* +AttrValue_ListValue::mutable_type() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.type) + return &type_; +} + +// repeated .tensorflow.TensorShapeProto shape = 7; +int AttrValue_ListValue::shape_size() const { + return shape_.size(); +} +void AttrValue_ListValue::clear_shape() { + shape_.Clear(); +} +const ::tensorflow::TensorShapeProto& AttrValue_ListValue::shape(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.shape) + return shape_.Get(index); +} +::tensorflow::TensorShapeProto* AttrValue_ListValue::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.shape) + return shape_.Mutable(index); +} +::tensorflow::TensorShapeProto* AttrValue_ListValue::add_shape() { + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.shape) + return shape_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto >* +AttrValue_ListValue::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.shape) + return &shape_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto >& +AttrValue_ListValue::shape() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.shape) + return shape_; +} + +// repeated .tensorflow.TensorProto tensor = 8; +int AttrValue_ListValue::tensor_size() const { + return tensor_.size(); +} +void AttrValue_ListValue::clear_tensor() { + tensor_.Clear(); +} +const ::tensorflow::TensorProto& AttrValue_ListValue::tensor(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.tensor) + return tensor_.Get(index); +} +::tensorflow::TensorProto* AttrValue_ListValue::mutable_tensor(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.tensor) + return tensor_.Mutable(index); +} +::tensorflow::TensorProto* AttrValue_ListValue::add_tensor() { + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.tensor) + return tensor_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::TensorProto >* +AttrValue_ListValue::mutable_tensor() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.tensor) + return &tensor_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorProto >& +AttrValue_ListValue::tensor() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.tensor) + return tensor_; +} + +inline const AttrValue_ListValue* AttrValue_ListValue::internal_default_instance() { + return &AttrValue_ListValue_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// AttrValue + +// optional bytes s = 2; +bool AttrValue::has_s() const { + return value_case() == kS; +} +void AttrValue::set_has_s() { + _oneof_case_[0] = kS; +} +void AttrValue::clear_s() { + if (has_s()) { + value_.s_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + clear_has_value(); + } +} +const ::std::string& AttrValue::s() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.s) + if (has_s()) { + return value_.s_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return *&::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +void AttrValue::set_s(const ::std::string& value) { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.s_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.s) +} +void AttrValue::set_s(const char* value) { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.s_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(value), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.AttrValue.s) +} +void AttrValue::set_s(const void* value, + size_t size) { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.s_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.AttrValue.s) +} +::std::string* AttrValue::mutable_s() { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return value_.s_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.s) +} +::std::string* AttrValue::release_s() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.s) + if (has_s()) { + clear_has_value(); + return value_.s_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + } else { + return NULL; + } +} +::std::string* AttrValue::unsafe_arena_release_s() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.s) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (has_s()) { + clear_has_value(); + return value_.s_.UnsafeArenaRelease( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + } else { + return NULL; + } +} +void AttrValue::set_allocated_s(::std::string* s) { + if (!has_s()) { + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (s != NULL) { + set_has_s(); + value_.s_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), s, + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.s) +} +void AttrValue::unsafe_arena_set_allocated_s(::std::string* s) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (!has_s()) { + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (s) { + set_has_s(); + value_.s_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), s, GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.s) +} + +// optional int64 i = 3; +bool AttrValue::has_i() const { + return value_case() == kI; +} +void AttrValue::set_has_i() { + _oneof_case_[0] = kI; +} +void AttrValue::clear_i() { + if (has_i()) { + value_.i_ = GOOGLE_LONGLONG(0); + clear_has_value(); + } +} +::google::protobuf::int64 AttrValue::i() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.i) + if (has_i()) { + return value_.i_; + } + return GOOGLE_LONGLONG(0); +} +void AttrValue::set_i(::google::protobuf::int64 value) { + if (!has_i()) { + clear_value(); + set_has_i(); + } + value_.i_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.i) +} + +// optional float f = 4; +bool AttrValue::has_f() const { + return value_case() == kF; +} +void AttrValue::set_has_f() { + _oneof_case_[0] = kF; +} +void AttrValue::clear_f() { + if (has_f()) { + value_.f_ = 0; + clear_has_value(); + } +} +float AttrValue::f() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.f) + if (has_f()) { + return value_.f_; + } + return 0; +} +void AttrValue::set_f(float value) { + if (!has_f()) { + clear_value(); + set_has_f(); + } + value_.f_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.f) +} + +// optional bool b = 5; +bool AttrValue::has_b() const { + return value_case() == kB; +} +void AttrValue::set_has_b() { + _oneof_case_[0] = kB; +} +void AttrValue::clear_b() { + if (has_b()) { + value_.b_ = false; + clear_has_value(); + } +} +bool AttrValue::b() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.b) + if (has_b()) { + return value_.b_; + } + return false; +} +void AttrValue::set_b(bool value) { + if (!has_b()) { + clear_value(); + set_has_b(); + } + value_.b_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.b) +} + +// optional .tensorflow.DataType type = 6; +bool AttrValue::has_type() const { + return value_case() == kType; +} +void AttrValue::set_has_type() { + _oneof_case_[0] = kType; +} +void AttrValue::clear_type() { + if (has_type()) { + value_.type_ = 0; + clear_has_value(); + } +} +::tensorflow::DataType AttrValue::type() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.type) + if (has_type()) { + return static_cast< ::tensorflow::DataType >(value_.type_); + } + return static_cast< ::tensorflow::DataType >(0); +} +void AttrValue::set_type(::tensorflow::DataType value) { + if (!has_type()) { + clear_value(); + set_has_type(); + } + value_.type_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.type) +} + +// optional .tensorflow.TensorShapeProto shape = 7; +bool AttrValue::has_shape() const { + return value_case() == kShape; +} +void AttrValue::set_has_shape() { + _oneof_case_[0] = kShape; +} +void AttrValue::clear_shape() { + if (has_shape()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.shape_; + } + clear_has_value(); + } +} + const ::tensorflow::TensorShapeProto& AttrValue::shape() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.shape) + return has_shape() + ? *value_.shape_ + : ::tensorflow::TensorShapeProto::default_instance(); +} +::tensorflow::TensorShapeProto* AttrValue::mutable_shape() { + if (!has_shape()) { + clear_value(); + set_has_shape(); + value_.shape_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.shape) + return value_.shape_; +} +::tensorflow::TensorShapeProto* AttrValue::release_shape() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.shape) + if (has_shape()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::TensorShapeProto* temp = new ::tensorflow::TensorShapeProto(*value_.shape_); + value_.shape_ = NULL; + return temp; + } else { + ::tensorflow::TensorShapeProto* temp = value_.shape_; + value_.shape_ = NULL; + return temp; + } + } else { + return NULL; + } +} +void AttrValue::set_allocated_shape(::tensorflow::TensorShapeProto* shape) { + clear_value(); + if (shape) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(shape) == NULL) { + GetArenaNoVirtual()->Own(shape); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(shape)) { + ::tensorflow::TensorShapeProto* new_shape = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >( + GetArenaNoVirtual()); + new_shape->CopyFrom(*shape); + shape = new_shape; + } + set_has_shape(); + value_.shape_ = shape; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.shape) +} + ::tensorflow::TensorShapeProto* AttrValue::unsafe_arena_release_shape() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.shape) + if (has_shape()) { + clear_has_value(); + ::tensorflow::TensorShapeProto* temp = value_.shape_; + value_.shape_ = NULL; + return temp; + } else { + return NULL; + } +} + void AttrValue::unsafe_arena_set_allocated_shape(::tensorflow::TensorShapeProto* shape) { + clear_value(); + if (shape) { + set_has_shape(); + value_.shape_ = shape; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.shape) +} + +// optional .tensorflow.TensorProto tensor = 8; +bool AttrValue::has_tensor() const { + return value_case() == kTensor; +} +void AttrValue::set_has_tensor() { + _oneof_case_[0] = kTensor; +} +void AttrValue::clear_tensor() { + if (has_tensor()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.tensor_; + } + clear_has_value(); + } +} + const ::tensorflow::TensorProto& AttrValue::tensor() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.tensor) + return has_tensor() + ? *value_.tensor_ + : ::tensorflow::TensorProto::default_instance(); +} +::tensorflow::TensorProto* AttrValue::mutable_tensor() { + if (!has_tensor()) { + clear_value(); + set_has_tensor(); + value_.tensor_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorProto >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.tensor) + return value_.tensor_; +} +::tensorflow::TensorProto* AttrValue::release_tensor() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.tensor) + if (has_tensor()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::TensorProto* temp = new ::tensorflow::TensorProto(*value_.tensor_); + value_.tensor_ = NULL; + return temp; + } else { + ::tensorflow::TensorProto* temp = value_.tensor_; + value_.tensor_ = NULL; + return temp; + } + } else { + return NULL; + } +} +void AttrValue::set_allocated_tensor(::tensorflow::TensorProto* tensor) { + clear_value(); + if (tensor) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(tensor) == NULL) { + GetArenaNoVirtual()->Own(tensor); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(tensor)) { + ::tensorflow::TensorProto* new_tensor = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorProto >( + GetArenaNoVirtual()); + new_tensor->CopyFrom(*tensor); + tensor = new_tensor; + } + set_has_tensor(); + value_.tensor_ = tensor; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.tensor) +} + ::tensorflow::TensorProto* AttrValue::unsafe_arena_release_tensor() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.tensor) + if (has_tensor()) { + clear_has_value(); + ::tensorflow::TensorProto* temp = value_.tensor_; + value_.tensor_ = NULL; + return temp; + } else { + return NULL; + } +} + void AttrValue::unsafe_arena_set_allocated_tensor(::tensorflow::TensorProto* tensor) { + clear_value(); + if (tensor) { + set_has_tensor(); + value_.tensor_ = tensor; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.tensor) +} + +// optional .tensorflow.AttrValue.ListValue list = 1; +bool AttrValue::has_list() const { + return value_case() == kList; +} +void AttrValue::set_has_list() { + _oneof_case_[0] = kList; +} +void AttrValue::clear_list() { + if (has_list()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.list_; + } + clear_has_value(); + } +} + const ::tensorflow::AttrValue_ListValue& AttrValue::list() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.list) + return has_list() + ? *value_.list_ + : ::tensorflow::AttrValue_ListValue::default_instance(); +} +::tensorflow::AttrValue_ListValue* AttrValue::mutable_list() { + if (!has_list()) { + clear_value(); + set_has_list(); + value_.list_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue_ListValue >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.list) + return value_.list_; +} +::tensorflow::AttrValue_ListValue* AttrValue::release_list() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.list) + if (has_list()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::AttrValue_ListValue* temp = new ::tensorflow::AttrValue_ListValue(*value_.list_); + value_.list_ = NULL; + return temp; + } else { + ::tensorflow::AttrValue_ListValue* temp = value_.list_; + value_.list_ = NULL; + return temp; + } + } else { + return NULL; + } +} +void AttrValue::set_allocated_list(::tensorflow::AttrValue_ListValue* list) { + clear_value(); + if (list) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(list) == NULL) { + GetArenaNoVirtual()->Own(list); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(list)) { + ::tensorflow::AttrValue_ListValue* new_list = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue_ListValue >( + GetArenaNoVirtual()); + new_list->CopyFrom(*list); + list = new_list; + } + set_has_list(); + value_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.list) +} + ::tensorflow::AttrValue_ListValue* AttrValue::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.list) + if (has_list()) { + clear_has_value(); + ::tensorflow::AttrValue_ListValue* temp = value_.list_; + value_.list_ = NULL; + return temp; + } else { + return NULL; + } +} + void AttrValue::unsafe_arena_set_allocated_list(::tensorflow::AttrValue_ListValue* list) { + clear_value(); + if (list) { + set_has_list(); + value_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.list) +} + +// optional .tensorflow.NameAttrList func = 10; +bool AttrValue::has_func() const { + return value_case() == kFunc; +} +void AttrValue::set_has_func() { + _oneof_case_[0] = kFunc; +} +void AttrValue::clear_func() { + if (has_func()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.func_; + } + clear_has_value(); + } +} + const ::tensorflow::NameAttrList& AttrValue::func() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.func) + return has_func() + ? *value_.func_ + : ::tensorflow::NameAttrList::default_instance(); +} +::tensorflow::NameAttrList* AttrValue::mutable_func() { + if (!has_func()) { + clear_value(); + set_has_func(); + value_.func_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::NameAttrList >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.func) + return value_.func_; +} +::tensorflow::NameAttrList* AttrValue::release_func() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.func) + if (has_func()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::NameAttrList* temp = new ::tensorflow::NameAttrList(*value_.func_); + value_.func_ = NULL; + return temp; + } else { + ::tensorflow::NameAttrList* temp = value_.func_; + value_.func_ = NULL; + return temp; + } + } else { + return NULL; + } +} +void AttrValue::set_allocated_func(::tensorflow::NameAttrList* func) { + clear_value(); + if (func) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(func) == NULL) { + GetArenaNoVirtual()->Own(func); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(func)) { + ::tensorflow::NameAttrList* new_func = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::NameAttrList >( + GetArenaNoVirtual()); + new_func->CopyFrom(*func); + func = new_func; + } + set_has_func(); + value_.func_ = func; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.func) +} + ::tensorflow::NameAttrList* AttrValue::unsafe_arena_release_func() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.func) + if (has_func()) { + clear_has_value(); + ::tensorflow::NameAttrList* temp = value_.func_; + value_.func_ = NULL; + return temp; + } else { + return NULL; + } +} + void AttrValue::unsafe_arena_set_allocated_func(::tensorflow::NameAttrList* func) { + clear_value(); + if (func) { + set_has_func(); + value_.func_ = func; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.func) +} + +// optional string placeholder = 9; +bool AttrValue::has_placeholder() const { + return value_case() == kPlaceholder; +} +void AttrValue::set_has_placeholder() { + _oneof_case_[0] = kPlaceholder; +} +void AttrValue::clear_placeholder() { + if (has_placeholder()) { + value_.placeholder_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + clear_has_value(); + } +} +const ::std::string& AttrValue::placeholder() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.placeholder) + if (has_placeholder()) { + return value_.placeholder_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return *&::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +void AttrValue::set_placeholder(const ::std::string& value) { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.placeholder_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.placeholder) +} +void AttrValue::set_placeholder(const char* value) { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.placeholder_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(value), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.AttrValue.placeholder) +} +void AttrValue::set_placeholder(const char* value, + size_t size) { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.placeholder_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.AttrValue.placeholder) +} +::std::string* AttrValue::mutable_placeholder() { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return value_.placeholder_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.placeholder) +} +::std::string* AttrValue::release_placeholder() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.placeholder) + if (has_placeholder()) { + clear_has_value(); + return value_.placeholder_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + } else { + return NULL; + } +} +::std::string* AttrValue::unsafe_arena_release_placeholder() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.placeholder) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (has_placeholder()) { + clear_has_value(); + return value_.placeholder_.UnsafeArenaRelease( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + } else { + return NULL; + } +} +void AttrValue::set_allocated_placeholder(::std::string* placeholder) { + if (!has_placeholder()) { + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (placeholder != NULL) { + set_has_placeholder(); + value_.placeholder_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), placeholder, + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.placeholder) +} +void AttrValue::unsafe_arena_set_allocated_placeholder(::std::string* placeholder) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (!has_placeholder()) { + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (placeholder) { + set_has_placeholder(); + value_.placeholder_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), placeholder, GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.placeholder) +} + +bool AttrValue::has_value() const { + return value_case() != VALUE_NOT_SET; +} +void AttrValue::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +AttrValue::ValueCase AttrValue::value_case() const { + return AttrValue::ValueCase(_oneof_case_[0]); +} +inline const AttrValue* AttrValue::internal_default_instance() { + return &AttrValue_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NameAttrList::kNameFieldNumber; +const int NameAttrList::kAttrFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NameAttrList::NameAttrList() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_attr_5fvalue_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.NameAttrList) +} +NameAttrList::NameAttrList(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + attr_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_attr_5fvalue_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.NameAttrList) +} + +void NameAttrList::InitAsDefaultInstance() { +} + +NameAttrList::NameAttrList(const NameAttrList& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.NameAttrList) +} + +void NameAttrList::SharedCtor() { + attr_.SetAssignDescriptorCallback( + protobuf_AssignDescriptorsOnce); + attr_.SetEntryDescriptor( + &::tensorflow::NameAttrList_AttrEntry_descriptor_); + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + _cached_size_ = 0; +} + +NameAttrList::~NameAttrList() { + // @@protoc_insertion_point(destructor:tensorflow.NameAttrList) + SharedDtor(); +} + +void NameAttrList::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + name_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); +} + +void NameAttrList::ArenaDtor(void* object) { + NameAttrList* _this = reinterpret_cast< NameAttrList* >(object); + (void)_this; +} +void NameAttrList::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void NameAttrList::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NameAttrList::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NameAttrList_descriptor_; +} + +const NameAttrList& NameAttrList::default_instance() { + protobuf_InitDefaults_attr_5fvalue_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NameAttrList_default_instance_; + +NameAttrList* NameAttrList::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void NameAttrList::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.NameAttrList) + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + attr_.Clear(); +} + +bool NameAttrList::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.NameAttrList) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.NameAttrList.name")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_attr; + break; + } + + // map attr = 2; + case 2: { + if (tag == 18) { + parse_attr: + DO_(input->IncrementRecursionDepth()); + parse_loop_attr: + NameAttrList_AttrEntry::Parser< ::google::protobuf::internal::MapField< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 >, + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue > > parser(&attr_); + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, &parser)); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + parser.key().data(), parser.key().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.NameAttrList.AttrEntry.key")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_loop_attr; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.NameAttrList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.NameAttrList) + return false; +#undef DO_ +} + +void NameAttrList::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.NameAttrList) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NameAttrList.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // map attr = 2; + if (!this->attr().empty()) { + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::google::protobuf::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), p->first.length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NameAttrList.AttrEntry.key"); + } + }; + + if (output->IsSerializationDeterminstic() && + this->attr().size() > 1) { + ::google::protobuf::scoped_array items( + new SortItem[this->attr().size()]); + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::size_type size_type; + size_type n = 0; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it, ++n) { + items[n] = SortItem(&*it); + } + ::std::sort(&items[0], &items[n], Less()); + ::google::protobuf::scoped_ptr entry; + for (size_type i = 0; i < n; i++) { + entry.reset(attr_.NewEntryWrapper( + items[i]->first, items[i]->second)); + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *entry, output); + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(items[i]); + } + } else { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + entry.reset(attr_.NewEntryWrapper( + it->first, it->second)); + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *entry, output); + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(&*it); + } + } + } + + // @@protoc_insertion_point(serialize_end:tensorflow.NameAttrList) +} + +::google::protobuf::uint8* NameAttrList::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.NameAttrList) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NameAttrList.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // map attr = 2; + if (!this->attr().empty()) { + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::google::protobuf::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), p->first.length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NameAttrList.AttrEntry.key"); + } + }; + + if (deterministic && + this->attr().size() > 1) { + ::google::protobuf::scoped_array items( + new SortItem[this->attr().size()]); + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::size_type size_type; + size_type n = 0; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it, ++n) { + items[n] = SortItem(&*it); + } + ::std::sort(&items[0], &items[n], Less()); + ::google::protobuf::scoped_ptr entry; + for (size_type i = 0; i < n; i++) { + entry.reset(attr_.NewEntryWrapper( + items[i]->first, items[i]->second)); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, *entry, deterministic, target); +; + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(items[i]); + } + } else { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + entry.reset(attr_.NewEntryWrapper( + it->first, it->second)); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, *entry, deterministic, target); +; + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(&*it); + } + } + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.NameAttrList) + return target; +} + +size_t NameAttrList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.NameAttrList) + size_t total_size = 0; + + // optional string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // map attr = 2; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->attr_size()); + { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + if (entry.get() != NULL && entry->GetArena() != NULL) { + entry.release(); + } + entry.reset(attr_.NewEntryWrapper(it->first, it->second)); + total_size += ::google::protobuf::internal::WireFormatLite:: + MessageSizeNoVirtual(*entry); + } + if (entry.get() != NULL && entry->GetArena() != NULL) { + entry.release(); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NameAttrList::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.NameAttrList) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NameAttrList* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.NameAttrList) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.NameAttrList) + UnsafeMergeFrom(*source); + } +} + +void NameAttrList::MergeFrom(const NameAttrList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.NameAttrList) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NameAttrList::UnsafeMergeFrom(const NameAttrList& from) { + GOOGLE_DCHECK(&from != this); + attr_.MergeFrom(from.attr_); + if (from.name().size() > 0) { + set_name(from.name()); + } +} + +void NameAttrList::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.NameAttrList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NameAttrList::CopyFrom(const NameAttrList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.NameAttrList) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NameAttrList::IsInitialized() const { + + return true; +} + +void NameAttrList::Swap(NameAttrList* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + NameAttrList temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void NameAttrList::UnsafeArenaSwap(NameAttrList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void NameAttrList::InternalSwap(NameAttrList* other) { + name_.Swap(&other->name_); + attr_.Swap(&other->attr_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NameAttrList::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NameAttrList_descriptor_; + metadata.reflection = NameAttrList_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NameAttrList + +// optional string name = 1; +void NameAttrList::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& NameAttrList::name() const { + // @@protoc_insertion_point(field_get:tensorflow.NameAttrList.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void NameAttrList::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NameAttrList.name) +} +void NameAttrList::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NameAttrList.name) +} +void NameAttrList::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NameAttrList.name) +} +::std::string* NameAttrList::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NameAttrList.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NameAttrList::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.NameAttrList.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NameAttrList::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NameAttrList.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void NameAttrList::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NameAttrList.name) +} +void NameAttrList::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NameAttrList.name) +} + +// map attr = 2; +int NameAttrList::attr_size() const { + return attr_.size(); +} +void NameAttrList::clear_attr() { + attr_.Clear(); +} + const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& +NameAttrList::attr() const { + // @@protoc_insertion_point(field_map:tensorflow.NameAttrList.attr) + return attr_.GetMap(); +} + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* +NameAttrList::mutable_attr() { + // @@protoc_insertion_point(field_mutable_map:tensorflow.NameAttrList.attr) + return attr_.MutableMap(); +} + +inline const NameAttrList* NameAttrList::internal_default_instance() { + return &NameAttrList_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/attr_value.pb.h b/modules/dnn/misc/tensorflow/attr_value.pb.h new file mode 100644 index 0000000000..d37a724ab1 --- /dev/null +++ b/modules/dnn/misc/tensorflow/attr_value.pb.h @@ -0,0 +1,1697 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: attr_value.proto + +#ifndef PROTOBUF_attr_5fvalue_2eproto__INCLUDED +#define PROTOBUF_attr_5fvalue_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "tensor.pb.h" +#include "tensor_shape.pb.h" +#include "types.pb.h" +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_attr_5fvalue_2eproto(); +void protobuf_InitDefaults_attr_5fvalue_2eproto(); +void protobuf_AssignDesc_attr_5fvalue_2eproto(); +void protobuf_ShutdownFile_attr_5fvalue_2eproto(); + +class AttrValue; +class AttrValue_ListValue; +class NameAttrList; + +// =================================================================== + +class AttrValue_ListValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.AttrValue.ListValue) */ { + public: + AttrValue_ListValue(); + virtual ~AttrValue_ListValue(); + + AttrValue_ListValue(const AttrValue_ListValue& from); + + inline AttrValue_ListValue& operator=(const AttrValue_ListValue& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const AttrValue_ListValue& default_instance(); + + static const AttrValue_ListValue* internal_default_instance(); + + void UnsafeArenaSwap(AttrValue_ListValue* other); + void Swap(AttrValue_ListValue* other); + + // implements Message ---------------------------------------------- + + inline AttrValue_ListValue* New() const { return New(NULL); } + + AttrValue_ListValue* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AttrValue_ListValue& from); + void MergeFrom(const AttrValue_ListValue& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(AttrValue_ListValue* other); + void UnsafeMergeFrom(const AttrValue_ListValue& from); + protected: + explicit AttrValue_ListValue(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated bytes s = 2; + int s_size() const; + void clear_s(); + static const int kSFieldNumber = 2; + const ::std::string& s(int index) const; + ::std::string* mutable_s(int index); + void set_s(int index, const ::std::string& value); + void set_s(int index, const char* value); + void set_s(int index, const void* value, size_t size); + ::std::string* add_s(); + void add_s(const ::std::string& value); + void add_s(const char* value); + void add_s(const void* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& s() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_s(); + + // repeated int64 i = 3 [packed = true]; + int i_size() const; + void clear_i(); + static const int kIFieldNumber = 3; + ::google::protobuf::int64 i(int index) const; + void set_i(int index, ::google::protobuf::int64 value); + void add_i(::google::protobuf::int64 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& + i() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int64 >* + mutable_i(); + + // repeated float f = 4 [packed = true]; + int f_size() const; + void clear_f(); + static const int kFFieldNumber = 4; + float f(int index) const; + void set_f(int index, float value); + void add_f(float value); + const ::google::protobuf::RepeatedField< float >& + f() const; + ::google::protobuf::RepeatedField< float >* + mutable_f(); + + // repeated bool b = 5 [packed = true]; + int b_size() const; + void clear_b(); + static const int kBFieldNumber = 5; + bool b(int index) const; + void set_b(int index, bool value); + void add_b(bool value); + const ::google::protobuf::RepeatedField< bool >& + b() const; + ::google::protobuf::RepeatedField< bool >* + mutable_b(); + + // repeated .tensorflow.DataType type = 6 [packed = true]; + int type_size() const; + void clear_type(); + static const int kTypeFieldNumber = 6; + ::tensorflow::DataType type(int index) const; + void set_type(int index, ::tensorflow::DataType value); + void add_type(::tensorflow::DataType value); + const ::google::protobuf::RepeatedField& type() const; + ::google::protobuf::RepeatedField* mutable_type(); + + // repeated .tensorflow.TensorShapeProto shape = 7; + int shape_size() const; + void clear_shape(); + static const int kShapeFieldNumber = 7; + const ::tensorflow::TensorShapeProto& shape(int index) const; + ::tensorflow::TensorShapeProto* mutable_shape(int index); + ::tensorflow::TensorShapeProto* add_shape(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto >* + mutable_shape(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto >& + shape() const; + + // repeated .tensorflow.TensorProto tensor = 8; + int tensor_size() const; + void clear_tensor(); + static const int kTensorFieldNumber = 8; + const ::tensorflow::TensorProto& tensor(int index) const; + ::tensorflow::TensorProto* mutable_tensor(int index); + ::tensorflow::TensorProto* add_tensor(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorProto >* + mutable_tensor(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorProto >& + tensor() const; + + // @@protoc_insertion_point(class_scope:tensorflow.AttrValue.ListValue) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::std::string> s_; + ::google::protobuf::RepeatedField< ::google::protobuf::int64 > i_; + mutable int _i_cached_byte_size_; + ::google::protobuf::RepeatedField< float > f_; + mutable int _f_cached_byte_size_; + ::google::protobuf::RepeatedField< bool > b_; + mutable int _b_cached_byte_size_; + ::google::protobuf::RepeatedField type_; + mutable int _type_cached_byte_size_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto > shape_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorProto > tensor_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_attr_5fvalue_2eproto_impl(); + friend void protobuf_AddDesc_attr_5fvalue_2eproto_impl(); + friend void protobuf_AssignDesc_attr_5fvalue_2eproto(); + friend void protobuf_ShutdownFile_attr_5fvalue_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed AttrValue_ListValue_default_instance_; + +// ------------------------------------------------------------------- + +class AttrValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.AttrValue) */ { + public: + AttrValue(); + virtual ~AttrValue(); + + AttrValue(const AttrValue& from); + + inline AttrValue& operator=(const AttrValue& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const AttrValue& default_instance(); + + enum ValueCase { + kS = 2, + kI = 3, + kF = 4, + kB = 5, + kType = 6, + kShape = 7, + kTensor = 8, + kList = 1, + kFunc = 10, + kPlaceholder = 9, + VALUE_NOT_SET = 0, + }; + + static const AttrValue* internal_default_instance(); + + void UnsafeArenaSwap(AttrValue* other); + void Swap(AttrValue* other); + + // implements Message ---------------------------------------------- + + inline AttrValue* New() const { return New(NULL); } + + AttrValue* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AttrValue& from); + void MergeFrom(const AttrValue& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(AttrValue* other); + void UnsafeMergeFrom(const AttrValue& from); + protected: + explicit AttrValue(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef AttrValue_ListValue ListValue; + + // accessors ------------------------------------------------------- + + // optional bytes s = 2; + private: + bool has_s() const; + public: + void clear_s(); + static const int kSFieldNumber = 2; + const ::std::string& s() const; + void set_s(const ::std::string& value); + void set_s(const char* value); + void set_s(const void* value, size_t size); + ::std::string* mutable_s(); + ::std::string* release_s(); + void set_allocated_s(::std::string* s); + ::std::string* unsafe_arena_release_s(); + void unsafe_arena_set_allocated_s( + ::std::string* s); + + // optional int64 i = 3; + private: + bool has_i() const; + public: + void clear_i(); + static const int kIFieldNumber = 3; + ::google::protobuf::int64 i() const; + void set_i(::google::protobuf::int64 value); + + // optional float f = 4; + private: + bool has_f() const; + public: + void clear_f(); + static const int kFFieldNumber = 4; + float f() const; + void set_f(float value); + + // optional bool b = 5; + private: + bool has_b() const; + public: + void clear_b(); + static const int kBFieldNumber = 5; + bool b() const; + void set_b(bool value); + + // optional .tensorflow.DataType type = 6; + private: + bool has_type() const; + public: + void clear_type(); + static const int kTypeFieldNumber = 6; + ::tensorflow::DataType type() const; + void set_type(::tensorflow::DataType value); + + // optional .tensorflow.TensorShapeProto shape = 7; + bool has_shape() const; + void clear_shape(); + static const int kShapeFieldNumber = 7; + private: + void _slow_mutable_shape(); + void _slow_set_allocated_shape( + ::google::protobuf::Arena* message_arena, ::tensorflow::TensorShapeProto** shape); + ::tensorflow::TensorShapeProto* _slow_release_shape(); + public: + const ::tensorflow::TensorShapeProto& shape() const; + ::tensorflow::TensorShapeProto* mutable_shape(); + ::tensorflow::TensorShapeProto* release_shape(); + void set_allocated_shape(::tensorflow::TensorShapeProto* shape); + ::tensorflow::TensorShapeProto* unsafe_arena_release_shape(); + void unsafe_arena_set_allocated_shape( + ::tensorflow::TensorShapeProto* shape); + + // optional .tensorflow.TensorProto tensor = 8; + bool has_tensor() const; + void clear_tensor(); + static const int kTensorFieldNumber = 8; + private: + void _slow_mutable_tensor(); + void _slow_set_allocated_tensor( + ::google::protobuf::Arena* message_arena, ::tensorflow::TensorProto** tensor); + ::tensorflow::TensorProto* _slow_release_tensor(); + public: + const ::tensorflow::TensorProto& tensor() const; + ::tensorflow::TensorProto* mutable_tensor(); + ::tensorflow::TensorProto* release_tensor(); + void set_allocated_tensor(::tensorflow::TensorProto* tensor); + ::tensorflow::TensorProto* unsafe_arena_release_tensor(); + void unsafe_arena_set_allocated_tensor( + ::tensorflow::TensorProto* tensor); + + // optional .tensorflow.AttrValue.ListValue list = 1; + bool has_list() const; + void clear_list(); + static const int kListFieldNumber = 1; + private: + void _slow_mutable_list(); + void _slow_set_allocated_list( + ::google::protobuf::Arena* message_arena, ::tensorflow::AttrValue_ListValue** list); + ::tensorflow::AttrValue_ListValue* _slow_release_list(); + public: + const ::tensorflow::AttrValue_ListValue& list() const; + ::tensorflow::AttrValue_ListValue* mutable_list(); + ::tensorflow::AttrValue_ListValue* release_list(); + void set_allocated_list(::tensorflow::AttrValue_ListValue* list); + ::tensorflow::AttrValue_ListValue* unsafe_arena_release_list(); + void unsafe_arena_set_allocated_list( + ::tensorflow::AttrValue_ListValue* list); + + // optional .tensorflow.NameAttrList func = 10; + bool has_func() const; + void clear_func(); + static const int kFuncFieldNumber = 10; + private: + void _slow_mutable_func(); + void _slow_set_allocated_func( + ::google::protobuf::Arena* message_arena, ::tensorflow::NameAttrList** func); + ::tensorflow::NameAttrList* _slow_release_func(); + public: + const ::tensorflow::NameAttrList& func() const; + ::tensorflow::NameAttrList* mutable_func(); + ::tensorflow::NameAttrList* release_func(); + void set_allocated_func(::tensorflow::NameAttrList* func); + ::tensorflow::NameAttrList* unsafe_arena_release_func(); + void unsafe_arena_set_allocated_func( + ::tensorflow::NameAttrList* func); + + // optional string placeholder = 9; + private: + bool has_placeholder() const; + public: + void clear_placeholder(); + static const int kPlaceholderFieldNumber = 9; + const ::std::string& placeholder() const; + void set_placeholder(const ::std::string& value); + void set_placeholder(const char* value); + void set_placeholder(const char* value, size_t size); + ::std::string* mutable_placeholder(); + ::std::string* release_placeholder(); + void set_allocated_placeholder(::std::string* placeholder); + ::std::string* unsafe_arena_release_placeholder(); + void unsafe_arena_set_allocated_placeholder( + ::std::string* placeholder); + + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:tensorflow.AttrValue) + private: + inline void set_has_s(); + inline void set_has_i(); + inline void set_has_f(); + inline void set_has_b(); + inline void set_has_type(); + inline void set_has_shape(); + inline void set_has_tensor(); + inline void set_has_list(); + inline void set_has_func(); + inline void set_has_placeholder(); + + inline bool has_value() const; + void clear_value(); + inline void clear_has_value(); + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union ValueUnion { + ValueUnion() {} + ::google::protobuf::internal::ArenaStringPtr s_; + ::google::protobuf::int64 i_; + float f_; + bool b_; + int type_; + ::tensorflow::TensorShapeProto* shape_; + ::tensorflow::TensorProto* tensor_; + ::tensorflow::AttrValue_ListValue* list_; + ::tensorflow::NameAttrList* func_; + ::google::protobuf::internal::ArenaStringPtr placeholder_; + } value_; + mutable int _cached_size_; + ::google::protobuf::uint32 _oneof_case_[1]; + + friend void protobuf_InitDefaults_attr_5fvalue_2eproto_impl(); + friend void protobuf_AddDesc_attr_5fvalue_2eproto_impl(); + friend void protobuf_AssignDesc_attr_5fvalue_2eproto(); + friend void protobuf_ShutdownFile_attr_5fvalue_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed AttrValue_default_instance_; + +// ------------------------------------------------------------------- + +class NameAttrList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.NameAttrList) */ { + public: + NameAttrList(); + virtual ~NameAttrList(); + + NameAttrList(const NameAttrList& from); + + inline NameAttrList& operator=(const NameAttrList& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const NameAttrList& default_instance(); + + static const NameAttrList* internal_default_instance(); + + void UnsafeArenaSwap(NameAttrList* other); + void Swap(NameAttrList* other); + + // implements Message ---------------------------------------------- + + inline NameAttrList* New() const { return New(NULL); } + + NameAttrList* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NameAttrList& from); + void MergeFrom(const NameAttrList& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NameAttrList* other); + void UnsafeMergeFrom(const NameAttrList& from); + protected: + explicit NameAttrList(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + + // accessors ------------------------------------------------------- + + // optional string name = 1; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + ::std::string* unsafe_arena_release_name(); + void unsafe_arena_set_allocated_name( + ::std::string* name); + + // map attr = 2; + int attr_size() const; + void clear_attr(); + static const int kAttrFieldNumber = 2; + const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& + attr() const; + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* + mutable_attr(); + + // @@protoc_insertion_point(class_scope:tensorflow.NameAttrList) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + typedef ::google::protobuf::internal::MapEntryLite< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 > + NameAttrList_AttrEntry; + ::google::protobuf::internal::MapField< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 > attr_; + ::google::protobuf::internal::ArenaStringPtr name_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_attr_5fvalue_2eproto_impl(); + friend void protobuf_AddDesc_attr_5fvalue_2eproto_impl(); + friend void protobuf_AssignDesc_attr_5fvalue_2eproto(); + friend void protobuf_ShutdownFile_attr_5fvalue_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NameAttrList_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// AttrValue_ListValue + +// repeated bytes s = 2; +inline int AttrValue_ListValue::s_size() const { + return s_.size(); +} +inline void AttrValue_ListValue::clear_s() { + s_.Clear(); +} +inline const ::std::string& AttrValue_ListValue::s(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.s) + return s_.Get(index); +} +inline ::std::string* AttrValue_ListValue::mutable_s(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.s) + return s_.Mutable(index); +} +inline void AttrValue_ListValue::set_s(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.s) + s_.Mutable(index)->assign(value); +} +inline void AttrValue_ListValue::set_s(int index, const char* value) { + s_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.AttrValue.ListValue.s) +} +inline void AttrValue_ListValue::set_s(int index, const void* value, size_t size) { + s_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.AttrValue.ListValue.s) +} +inline ::std::string* AttrValue_ListValue::add_s() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.AttrValue.ListValue.s) + return s_.Add(); +} +inline void AttrValue_ListValue::add_s(const ::std::string& value) { + s_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.s) +} +inline void AttrValue_ListValue::add_s(const char* value) { + s_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.AttrValue.ListValue.s) +} +inline void AttrValue_ListValue::add_s(const void* value, size_t size) { + s_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.AttrValue.ListValue.s) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +AttrValue_ListValue::s() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.s) + return s_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +AttrValue_ListValue::mutable_s() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.s) + return &s_; +} + +// repeated int64 i = 3 [packed = true]; +inline int AttrValue_ListValue::i_size() const { + return i_.size(); +} +inline void AttrValue_ListValue::clear_i() { + i_.Clear(); +} +inline ::google::protobuf::int64 AttrValue_ListValue::i(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.i) + return i_.Get(index); +} +inline void AttrValue_ListValue::set_i(int index, ::google::protobuf::int64 value) { + i_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.i) +} +inline void AttrValue_ListValue::add_i(::google::protobuf::int64 value) { + i_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.i) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& +AttrValue_ListValue::i() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.i) + return i_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >* +AttrValue_ListValue::mutable_i() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.i) + return &i_; +} + +// repeated float f = 4 [packed = true]; +inline int AttrValue_ListValue::f_size() const { + return f_.size(); +} +inline void AttrValue_ListValue::clear_f() { + f_.Clear(); +} +inline float AttrValue_ListValue::f(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.f) + return f_.Get(index); +} +inline void AttrValue_ListValue::set_f(int index, float value) { + f_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.f) +} +inline void AttrValue_ListValue::add_f(float value) { + f_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.f) +} +inline const ::google::protobuf::RepeatedField< float >& +AttrValue_ListValue::f() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.f) + return f_; +} +inline ::google::protobuf::RepeatedField< float >* +AttrValue_ListValue::mutable_f() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.f) + return &f_; +} + +// repeated bool b = 5 [packed = true]; +inline int AttrValue_ListValue::b_size() const { + return b_.size(); +} +inline void AttrValue_ListValue::clear_b() { + b_.Clear(); +} +inline bool AttrValue_ListValue::b(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.b) + return b_.Get(index); +} +inline void AttrValue_ListValue::set_b(int index, bool value) { + b_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.b) +} +inline void AttrValue_ListValue::add_b(bool value) { + b_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.b) +} +inline const ::google::protobuf::RepeatedField< bool >& +AttrValue_ListValue::b() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.b) + return b_; +} +inline ::google::protobuf::RepeatedField< bool >* +AttrValue_ListValue::mutable_b() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.b) + return &b_; +} + +// repeated .tensorflow.DataType type = 6 [packed = true]; +inline int AttrValue_ListValue::type_size() const { + return type_.size(); +} +inline void AttrValue_ListValue::clear_type() { + type_.Clear(); +} +inline ::tensorflow::DataType AttrValue_ListValue::type(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.type) + return static_cast< ::tensorflow::DataType >(type_.Get(index)); +} +inline void AttrValue_ListValue::set_type(int index, ::tensorflow::DataType value) { + type_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.type) +} +inline void AttrValue_ListValue::add_type(::tensorflow::DataType value) { + type_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.type) +} +inline const ::google::protobuf::RepeatedField& +AttrValue_ListValue::type() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.type) + return type_; +} +inline ::google::protobuf::RepeatedField* +AttrValue_ListValue::mutable_type() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.type) + return &type_; +} + +// repeated .tensorflow.TensorShapeProto shape = 7; +inline int AttrValue_ListValue::shape_size() const { + return shape_.size(); +} +inline void AttrValue_ListValue::clear_shape() { + shape_.Clear(); +} +inline const ::tensorflow::TensorShapeProto& AttrValue_ListValue::shape(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.shape) + return shape_.Get(index); +} +inline ::tensorflow::TensorShapeProto* AttrValue_ListValue::mutable_shape(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.shape) + return shape_.Mutable(index); +} +inline ::tensorflow::TensorShapeProto* AttrValue_ListValue::add_shape() { + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.shape) + return shape_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto >* +AttrValue_ListValue::mutable_shape() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.shape) + return &shape_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto >& +AttrValue_ListValue::shape() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.shape) + return shape_; +} + +// repeated .tensorflow.TensorProto tensor = 8; +inline int AttrValue_ListValue::tensor_size() const { + return tensor_.size(); +} +inline void AttrValue_ListValue::clear_tensor() { + tensor_.Clear(); +} +inline const ::tensorflow::TensorProto& AttrValue_ListValue::tensor(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.tensor) + return tensor_.Get(index); +} +inline ::tensorflow::TensorProto* AttrValue_ListValue::mutable_tensor(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.tensor) + return tensor_.Mutable(index); +} +inline ::tensorflow::TensorProto* AttrValue_ListValue::add_tensor() { + // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.tensor) + return tensor_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorProto >* +AttrValue_ListValue::mutable_tensor() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.tensor) + return &tensor_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorProto >& +AttrValue_ListValue::tensor() const { + // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.tensor) + return tensor_; +} + +inline const AttrValue_ListValue* AttrValue_ListValue::internal_default_instance() { + return &AttrValue_ListValue_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// AttrValue + +// optional bytes s = 2; +inline bool AttrValue::has_s() const { + return value_case() == kS; +} +inline void AttrValue::set_has_s() { + _oneof_case_[0] = kS; +} +inline void AttrValue::clear_s() { + if (has_s()) { + value_.s_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + clear_has_value(); + } +} +inline const ::std::string& AttrValue::s() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.s) + if (has_s()) { + return value_.s_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return *&::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void AttrValue::set_s(const ::std::string& value) { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.s_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.s) +} +inline void AttrValue::set_s(const char* value) { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.s_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(value), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.AttrValue.s) +} +inline void AttrValue::set_s(const void* value, + size_t size) { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.s_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.AttrValue.s) +} +inline ::std::string* AttrValue::mutable_s() { + if (!has_s()) { + clear_value(); + set_has_s(); + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return value_.s_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.s) +} +inline ::std::string* AttrValue::release_s() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.s) + if (has_s()) { + clear_has_value(); + return value_.s_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + } else { + return NULL; + } +} +inline ::std::string* AttrValue::unsafe_arena_release_s() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.s) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (has_s()) { + clear_has_value(); + return value_.s_.UnsafeArenaRelease( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + } else { + return NULL; + } +} +inline void AttrValue::set_allocated_s(::std::string* s) { + if (!has_s()) { + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (s != NULL) { + set_has_s(); + value_.s_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), s, + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.s) +} +inline void AttrValue::unsafe_arena_set_allocated_s(::std::string* s) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (!has_s()) { + value_.s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (s) { + set_has_s(); + value_.s_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), s, GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.s) +} + +// optional int64 i = 3; +inline bool AttrValue::has_i() const { + return value_case() == kI; +} +inline void AttrValue::set_has_i() { + _oneof_case_[0] = kI; +} +inline void AttrValue::clear_i() { + if (has_i()) { + value_.i_ = GOOGLE_LONGLONG(0); + clear_has_value(); + } +} +inline ::google::protobuf::int64 AttrValue::i() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.i) + if (has_i()) { + return value_.i_; + } + return GOOGLE_LONGLONG(0); +} +inline void AttrValue::set_i(::google::protobuf::int64 value) { + if (!has_i()) { + clear_value(); + set_has_i(); + } + value_.i_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.i) +} + +// optional float f = 4; +inline bool AttrValue::has_f() const { + return value_case() == kF; +} +inline void AttrValue::set_has_f() { + _oneof_case_[0] = kF; +} +inline void AttrValue::clear_f() { + if (has_f()) { + value_.f_ = 0; + clear_has_value(); + } +} +inline float AttrValue::f() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.f) + if (has_f()) { + return value_.f_; + } + return 0; +} +inline void AttrValue::set_f(float value) { + if (!has_f()) { + clear_value(); + set_has_f(); + } + value_.f_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.f) +} + +// optional bool b = 5; +inline bool AttrValue::has_b() const { + return value_case() == kB; +} +inline void AttrValue::set_has_b() { + _oneof_case_[0] = kB; +} +inline void AttrValue::clear_b() { + if (has_b()) { + value_.b_ = false; + clear_has_value(); + } +} +inline bool AttrValue::b() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.b) + if (has_b()) { + return value_.b_; + } + return false; +} +inline void AttrValue::set_b(bool value) { + if (!has_b()) { + clear_value(); + set_has_b(); + } + value_.b_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.b) +} + +// optional .tensorflow.DataType type = 6; +inline bool AttrValue::has_type() const { + return value_case() == kType; +} +inline void AttrValue::set_has_type() { + _oneof_case_[0] = kType; +} +inline void AttrValue::clear_type() { + if (has_type()) { + value_.type_ = 0; + clear_has_value(); + } +} +inline ::tensorflow::DataType AttrValue::type() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.type) + if (has_type()) { + return static_cast< ::tensorflow::DataType >(value_.type_); + } + return static_cast< ::tensorflow::DataType >(0); +} +inline void AttrValue::set_type(::tensorflow::DataType value) { + if (!has_type()) { + clear_value(); + set_has_type(); + } + value_.type_ = value; + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.type) +} + +// optional .tensorflow.TensorShapeProto shape = 7; +inline bool AttrValue::has_shape() const { + return value_case() == kShape; +} +inline void AttrValue::set_has_shape() { + _oneof_case_[0] = kShape; +} +inline void AttrValue::clear_shape() { + if (has_shape()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.shape_; + } + clear_has_value(); + } +} +inline const ::tensorflow::TensorShapeProto& AttrValue::shape() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.shape) + return has_shape() + ? *value_.shape_ + : ::tensorflow::TensorShapeProto::default_instance(); +} +inline ::tensorflow::TensorShapeProto* AttrValue::mutable_shape() { + if (!has_shape()) { + clear_value(); + set_has_shape(); + value_.shape_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.shape) + return value_.shape_; +} +inline ::tensorflow::TensorShapeProto* AttrValue::release_shape() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.shape) + if (has_shape()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::TensorShapeProto* temp = new ::tensorflow::TensorShapeProto(*value_.shape_); + value_.shape_ = NULL; + return temp; + } else { + ::tensorflow::TensorShapeProto* temp = value_.shape_; + value_.shape_ = NULL; + return temp; + } + } else { + return NULL; + } +} +inline void AttrValue::set_allocated_shape(::tensorflow::TensorShapeProto* shape) { + clear_value(); + if (shape) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(shape) == NULL) { + GetArenaNoVirtual()->Own(shape); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(shape)) { + ::tensorflow::TensorShapeProto* new_shape = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >( + GetArenaNoVirtual()); + new_shape->CopyFrom(*shape); + shape = new_shape; + } + set_has_shape(); + value_.shape_ = shape; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.shape) +} +inline ::tensorflow::TensorShapeProto* AttrValue::unsafe_arena_release_shape() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.shape) + if (has_shape()) { + clear_has_value(); + ::tensorflow::TensorShapeProto* temp = value_.shape_; + value_.shape_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void AttrValue::unsafe_arena_set_allocated_shape(::tensorflow::TensorShapeProto* shape) { + clear_value(); + if (shape) { + set_has_shape(); + value_.shape_ = shape; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.shape) +} + +// optional .tensorflow.TensorProto tensor = 8; +inline bool AttrValue::has_tensor() const { + return value_case() == kTensor; +} +inline void AttrValue::set_has_tensor() { + _oneof_case_[0] = kTensor; +} +inline void AttrValue::clear_tensor() { + if (has_tensor()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.tensor_; + } + clear_has_value(); + } +} +inline const ::tensorflow::TensorProto& AttrValue::tensor() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.tensor) + return has_tensor() + ? *value_.tensor_ + : ::tensorflow::TensorProto::default_instance(); +} +inline ::tensorflow::TensorProto* AttrValue::mutable_tensor() { + if (!has_tensor()) { + clear_value(); + set_has_tensor(); + value_.tensor_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorProto >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.tensor) + return value_.tensor_; +} +inline ::tensorflow::TensorProto* AttrValue::release_tensor() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.tensor) + if (has_tensor()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::TensorProto* temp = new ::tensorflow::TensorProto(*value_.tensor_); + value_.tensor_ = NULL; + return temp; + } else { + ::tensorflow::TensorProto* temp = value_.tensor_; + value_.tensor_ = NULL; + return temp; + } + } else { + return NULL; + } +} +inline void AttrValue::set_allocated_tensor(::tensorflow::TensorProto* tensor) { + clear_value(); + if (tensor) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(tensor) == NULL) { + GetArenaNoVirtual()->Own(tensor); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(tensor)) { + ::tensorflow::TensorProto* new_tensor = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorProto >( + GetArenaNoVirtual()); + new_tensor->CopyFrom(*tensor); + tensor = new_tensor; + } + set_has_tensor(); + value_.tensor_ = tensor; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.tensor) +} +inline ::tensorflow::TensorProto* AttrValue::unsafe_arena_release_tensor() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.tensor) + if (has_tensor()) { + clear_has_value(); + ::tensorflow::TensorProto* temp = value_.tensor_; + value_.tensor_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void AttrValue::unsafe_arena_set_allocated_tensor(::tensorflow::TensorProto* tensor) { + clear_value(); + if (tensor) { + set_has_tensor(); + value_.tensor_ = tensor; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.tensor) +} + +// optional .tensorflow.AttrValue.ListValue list = 1; +inline bool AttrValue::has_list() const { + return value_case() == kList; +} +inline void AttrValue::set_has_list() { + _oneof_case_[0] = kList; +} +inline void AttrValue::clear_list() { + if (has_list()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.list_; + } + clear_has_value(); + } +} +inline const ::tensorflow::AttrValue_ListValue& AttrValue::list() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.list) + return has_list() + ? *value_.list_ + : ::tensorflow::AttrValue_ListValue::default_instance(); +} +inline ::tensorflow::AttrValue_ListValue* AttrValue::mutable_list() { + if (!has_list()) { + clear_value(); + set_has_list(); + value_.list_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue_ListValue >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.list) + return value_.list_; +} +inline ::tensorflow::AttrValue_ListValue* AttrValue::release_list() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.list) + if (has_list()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::AttrValue_ListValue* temp = new ::tensorflow::AttrValue_ListValue(*value_.list_); + value_.list_ = NULL; + return temp; + } else { + ::tensorflow::AttrValue_ListValue* temp = value_.list_; + value_.list_ = NULL; + return temp; + } + } else { + return NULL; + } +} +inline void AttrValue::set_allocated_list(::tensorflow::AttrValue_ListValue* list) { + clear_value(); + if (list) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(list) == NULL) { + GetArenaNoVirtual()->Own(list); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(list)) { + ::tensorflow::AttrValue_ListValue* new_list = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue_ListValue >( + GetArenaNoVirtual()); + new_list->CopyFrom(*list); + list = new_list; + } + set_has_list(); + value_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.list) +} +inline ::tensorflow::AttrValue_ListValue* AttrValue::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.list) + if (has_list()) { + clear_has_value(); + ::tensorflow::AttrValue_ListValue* temp = value_.list_; + value_.list_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void AttrValue::unsafe_arena_set_allocated_list(::tensorflow::AttrValue_ListValue* list) { + clear_value(); + if (list) { + set_has_list(); + value_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.list) +} + +// optional .tensorflow.NameAttrList func = 10; +inline bool AttrValue::has_func() const { + return value_case() == kFunc; +} +inline void AttrValue::set_has_func() { + _oneof_case_[0] = kFunc; +} +inline void AttrValue::clear_func() { + if (has_func()) { + if (GetArenaNoVirtual() == NULL) { + delete value_.func_; + } + clear_has_value(); + } +} +inline const ::tensorflow::NameAttrList& AttrValue::func() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.func) + return has_func() + ? *value_.func_ + : ::tensorflow::NameAttrList::default_instance(); +} +inline ::tensorflow::NameAttrList* AttrValue::mutable_func() { + if (!has_func()) { + clear_value(); + set_has_func(); + value_.func_ = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::NameAttrList >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.func) + return value_.func_; +} +inline ::tensorflow::NameAttrList* AttrValue::release_func() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.func) + if (has_func()) { + clear_has_value(); + if (GetArenaNoVirtual() != NULL) { + ::tensorflow::NameAttrList* temp = new ::tensorflow::NameAttrList(*value_.func_); + value_.func_ = NULL; + return temp; + } else { + ::tensorflow::NameAttrList* temp = value_.func_; + value_.func_ = NULL; + return temp; + } + } else { + return NULL; + } +} +inline void AttrValue::set_allocated_func(::tensorflow::NameAttrList* func) { + clear_value(); + if (func) { + if (GetArenaNoVirtual() != NULL && + ::google::protobuf::Arena::GetArena(func) == NULL) { + GetArenaNoVirtual()->Own(func); + } else if (GetArenaNoVirtual() != + ::google::protobuf::Arena::GetArena(func)) { + ::tensorflow::NameAttrList* new_func = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::NameAttrList >( + GetArenaNoVirtual()); + new_func->CopyFrom(*func); + func = new_func; + } + set_has_func(); + value_.func_ = func; + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.func) +} +inline ::tensorflow::NameAttrList* AttrValue::unsafe_arena_release_func() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.func) + if (has_func()) { + clear_has_value(); + ::tensorflow::NameAttrList* temp = value_.func_; + value_.func_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void AttrValue::unsafe_arena_set_allocated_func(::tensorflow::NameAttrList* func) { + clear_value(); + if (func) { + set_has_func(); + value_.func_ = func; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.func) +} + +// optional string placeholder = 9; +inline bool AttrValue::has_placeholder() const { + return value_case() == kPlaceholder; +} +inline void AttrValue::set_has_placeholder() { + _oneof_case_[0] = kPlaceholder; +} +inline void AttrValue::clear_placeholder() { + if (has_placeholder()) { + value_.placeholder_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + clear_has_value(); + } +} +inline const ::std::string& AttrValue::placeholder() const { + // @@protoc_insertion_point(field_get:tensorflow.AttrValue.placeholder) + if (has_placeholder()) { + return value_.placeholder_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return *&::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void AttrValue::set_placeholder(const ::std::string& value) { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.placeholder_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.AttrValue.placeholder) +} +inline void AttrValue::set_placeholder(const char* value) { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.placeholder_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(value), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.AttrValue.placeholder) +} +inline void AttrValue::set_placeholder(const char* value, + size_t size) { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + value_.placeholder_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.AttrValue.placeholder) +} +inline ::std::string* AttrValue::mutable_placeholder() { + if (!has_placeholder()) { + clear_value(); + set_has_placeholder(); + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + return value_.placeholder_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.placeholder) +} +inline ::std::string* AttrValue::release_placeholder() { + // @@protoc_insertion_point(field_release:tensorflow.AttrValue.placeholder) + if (has_placeholder()) { + clear_has_value(); + return value_.placeholder_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + } else { + return NULL; + } +} +inline ::std::string* AttrValue::unsafe_arena_release_placeholder() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.placeholder) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (has_placeholder()) { + clear_has_value(); + return value_.placeholder_.UnsafeArenaRelease( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + } else { + return NULL; + } +} +inline void AttrValue::set_allocated_placeholder(::std::string* placeholder) { + if (!has_placeholder()) { + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (placeholder != NULL) { + set_has_placeholder(); + value_.placeholder_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), placeholder, + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.placeholder) +} +inline void AttrValue::unsafe_arena_set_allocated_placeholder(::std::string* placeholder) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (!has_placeholder()) { + value_.placeholder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + clear_value(); + if (placeholder) { + set_has_placeholder(); + value_.placeholder_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), placeholder, GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.placeholder) +} + +inline bool AttrValue::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void AttrValue::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +inline AttrValue::ValueCase AttrValue::value_case() const { + return AttrValue::ValueCase(_oneof_case_[0]); +} +inline const AttrValue* AttrValue::internal_default_instance() { + return &AttrValue_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NameAttrList + +// optional string name = 1; +inline void NameAttrList::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& NameAttrList::name() const { + // @@protoc_insertion_point(field_get:tensorflow.NameAttrList.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void NameAttrList::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NameAttrList.name) +} +inline void NameAttrList::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NameAttrList.name) +} +inline void NameAttrList::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NameAttrList.name) +} +inline ::std::string* NameAttrList::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NameAttrList.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NameAttrList::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.NameAttrList.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NameAttrList::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NameAttrList.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void NameAttrList::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NameAttrList.name) +} +inline void NameAttrList::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NameAttrList.name) +} + +// map attr = 2; +inline int NameAttrList::attr_size() const { + return attr_.size(); +} +inline void NameAttrList::clear_attr() { + attr_.Clear(); +} +inline const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& +NameAttrList::attr() const { + // @@protoc_insertion_point(field_map:tensorflow.NameAttrList.attr) + return attr_.GetMap(); +} +inline ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* +NameAttrList::mutable_attr() { + // @@protoc_insertion_point(field_mutable_map:tensorflow.NameAttrList.attr) + return attr_.MutableMap(); +} + +inline const NameAttrList* NameAttrList::internal_default_instance() { + return &NameAttrList_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_attr_5fvalue_2eproto__INCLUDED diff --git a/modules/dnn/misc/tensorflow/function.pb.cc b/modules/dnn/misc/tensorflow/function.pb.cc new file mode 100644 index 0000000000..408a07e394 --- /dev/null +++ b/modules/dnn/misc/tensorflow/function.pb.cc @@ -0,0 +1,2348 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: function.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "function.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::Descriptor* FunctionDefLibrary_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FunctionDefLibrary_reflection_ = NULL; +const ::google::protobuf::Descriptor* FunctionDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FunctionDef_reflection_ = NULL; +const ::google::protobuf::Descriptor* FunctionDef_Node_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FunctionDef_Node_reflection_ = NULL; +const ::google::protobuf::Descriptor* FunctionDef_Node_AttrEntry_descriptor_ = NULL; +const ::google::protobuf::Descriptor* GradientDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GradientDef_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_function_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_function_2eproto() { + protobuf_AddDesc_function_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "function.proto"); + GOOGLE_CHECK(file != NULL); + FunctionDefLibrary_descriptor_ = file->message_type(0); + static const int FunctionDefLibrary_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDefLibrary, function_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDefLibrary, gradient_), + }; + FunctionDefLibrary_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + FunctionDefLibrary_descriptor_, + FunctionDefLibrary::internal_default_instance(), + FunctionDefLibrary_offsets_, + -1, + -1, + -1, + sizeof(FunctionDefLibrary), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDefLibrary, _internal_metadata_)); + FunctionDef_descriptor_ = file->message_type(1); + static const int FunctionDef_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef, signature_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef, node_), + }; + FunctionDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + FunctionDef_descriptor_, + FunctionDef::internal_default_instance(), + FunctionDef_offsets_, + -1, + -1, + -1, + sizeof(FunctionDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef, _internal_metadata_)); + FunctionDef_Node_descriptor_ = FunctionDef_descriptor_->nested_type(0); + static const int FunctionDef_Node_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef_Node, ret_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef_Node, op_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef_Node, arg_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef_Node, dep_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef_Node, attr_), + }; + FunctionDef_Node_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + FunctionDef_Node_descriptor_, + FunctionDef_Node::internal_default_instance(), + FunctionDef_Node_offsets_, + -1, + -1, + -1, + sizeof(FunctionDef_Node), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FunctionDef_Node, _internal_metadata_)); + FunctionDef_Node_AttrEntry_descriptor_ = FunctionDef_Node_descriptor_->nested_type(0); + GradientDef_descriptor_ = file->message_type(2); + static const int GradientDef_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GradientDef, function_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GradientDef, gradient_func_), + }; + GradientDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + GradientDef_descriptor_, + GradientDef::internal_default_instance(), + GradientDef_offsets_, + -1, + -1, + -1, + sizeof(GradientDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GradientDef, _internal_metadata_)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_function_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FunctionDefLibrary_descriptor_, FunctionDefLibrary::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FunctionDef_descriptor_, FunctionDef::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FunctionDef_Node_descriptor_, FunctionDef_Node::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FunctionDef_Node_AttrEntry_descriptor_, + ::google::protobuf::internal::MapEntry< + ::std::string, + ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0>::CreateDefaultInstance( + FunctionDef_Node_AttrEntry_descriptor_)); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GradientDef_descriptor_, GradientDef::internal_default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_function_2eproto() { + FunctionDefLibrary_default_instance_.Shutdown(); + delete FunctionDefLibrary_reflection_; + FunctionDef_default_instance_.Shutdown(); + delete FunctionDef_reflection_; + FunctionDef_Node_default_instance_.Shutdown(); + delete FunctionDef_Node_reflection_; + GradientDef_default_instance_.Shutdown(); + delete GradientDef_reflection_; +} + +void protobuf_InitDefaults_function_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::tensorflow::protobuf_InitDefaults_attr_5fvalue_2eproto(); + ::tensorflow::protobuf_InitDefaults_op_5fdef_2eproto(); + FunctionDefLibrary_default_instance_.DefaultConstruct(); + FunctionDef_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + FunctionDef_Node_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + GradientDef_default_instance_.DefaultConstruct(); + FunctionDefLibrary_default_instance_.get_mutable()->InitAsDefaultInstance(); + FunctionDef_default_instance_.get_mutable()->InitAsDefaultInstance(); + FunctionDef_Node_default_instance_.get_mutable()->InitAsDefaultInstance(); + GradientDef_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_function_2eproto_once_); +void protobuf_InitDefaults_function_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_function_2eproto_once_, + &protobuf_InitDefaults_function_2eproto_impl); +} +void protobuf_AddDesc_function_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_function_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\016function.proto\022\ntensorflow\032\020attr_value" + ".proto\032\014op_def.proto\"j\n\022FunctionDefLibra" + "ry\022)\n\010function\030\001 \003(\0132\027.tensorflow.Functi" + "onDef\022)\n\010gradient\030\002 \003(\0132\027.tensorflow.Gra" + "dientDef\"\225\002\n\013FunctionDef\022$\n\tsignature\030\001 " + "\001(\0132\021.tensorflow.OpDef\022*\n\004node\030\002 \003(\0132\034.t" + "ensorflow.FunctionDef.Node\032\263\001\n\004Node\022\013\n\003r" + "et\030\001 \003(\t\022\n\n\002op\030\002 \001(\t\022\013\n\003arg\030\003 \003(\t\022\013\n\003dep" + "\030\004 \003(\t\0224\n\004attr\030\005 \003(\0132&.tensorflow.Functi" + "onDef.Node.AttrEntry\032B\n\tAttrEntry\022\013\n\003key" + "\030\001 \001(\t\022$\n\005value\030\002 \001(\0132\025.tensorflow.AttrV" + "alue:\0028\001\";\n\013GradientDef\022\025\n\rfunction_name" + "\030\001 \001(\t\022\025\n\rgradient_func\030\002 \001(\tB/\n\030org.ten" + "sorflow.frameworkB\016FunctionProtosP\001\370\001\001b\006" + "proto3", 566); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "function.proto", &protobuf_RegisterTypes); + ::tensorflow::protobuf_AddDesc_attr_5fvalue_2eproto(); + ::tensorflow::protobuf_AddDesc_op_5fdef_2eproto(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_function_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_function_2eproto_once_); +void protobuf_AddDesc_function_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_function_2eproto_once_, + &protobuf_AddDesc_function_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_function_2eproto { + StaticDescriptorInitializer_function_2eproto() { + protobuf_AddDesc_function_2eproto(); + } +} static_descriptor_initializer_function_2eproto_; + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int FunctionDefLibrary::kFunctionFieldNumber; +const int FunctionDefLibrary::kGradientFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +FunctionDefLibrary::FunctionDefLibrary() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_function_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.FunctionDefLibrary) +} +FunctionDefLibrary::FunctionDefLibrary(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + function_(arena), + gradient_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_function_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.FunctionDefLibrary) +} + +void FunctionDefLibrary::InitAsDefaultInstance() { +} + +FunctionDefLibrary::FunctionDefLibrary(const FunctionDefLibrary& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.FunctionDefLibrary) +} + +void FunctionDefLibrary::SharedCtor() { + _cached_size_ = 0; +} + +FunctionDefLibrary::~FunctionDefLibrary() { + // @@protoc_insertion_point(destructor:tensorflow.FunctionDefLibrary) + SharedDtor(); +} + +void FunctionDefLibrary::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + +} + +void FunctionDefLibrary::ArenaDtor(void* object) { + FunctionDefLibrary* _this = reinterpret_cast< FunctionDefLibrary* >(object); + (void)_this; +} +void FunctionDefLibrary::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void FunctionDefLibrary::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FunctionDefLibrary::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FunctionDefLibrary_descriptor_; +} + +const FunctionDefLibrary& FunctionDefLibrary::default_instance() { + protobuf_InitDefaults_function_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed FunctionDefLibrary_default_instance_; + +FunctionDefLibrary* FunctionDefLibrary::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void FunctionDefLibrary::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.FunctionDefLibrary) + function_.Clear(); + gradient_.Clear(); +} + +bool FunctionDefLibrary::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.FunctionDefLibrary) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .tensorflow.FunctionDef function = 1; + case 1: { + if (tag == 10) { + DO_(input->IncrementRecursionDepth()); + parse_loop_function: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_function())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_loop_function; + if (input->ExpectTag(18)) goto parse_loop_gradient; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .tensorflow.GradientDef gradient = 2; + case 2: { + if (tag == 18) { + DO_(input->IncrementRecursionDepth()); + parse_loop_gradient: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_gradient())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_loop_gradient; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.FunctionDefLibrary) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.FunctionDefLibrary) + return false; +#undef DO_ +} + +void FunctionDefLibrary::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.FunctionDefLibrary) + // repeated .tensorflow.FunctionDef function = 1; + for (unsigned int i = 0, n = this->function_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->function(i), output); + } + + // repeated .tensorflow.GradientDef gradient = 2; + for (unsigned int i = 0, n = this->gradient_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->gradient(i), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.FunctionDefLibrary) +} + +::google::protobuf::uint8* FunctionDefLibrary::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.FunctionDefLibrary) + // repeated .tensorflow.FunctionDef function = 1; + for (unsigned int i = 0, n = this->function_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, this->function(i), false, target); + } + + // repeated .tensorflow.GradientDef gradient = 2; + for (unsigned int i = 0, n = this->gradient_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, this->gradient(i), false, target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.FunctionDefLibrary) + return target; +} + +size_t FunctionDefLibrary::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.FunctionDefLibrary) + size_t total_size = 0; + + // repeated .tensorflow.FunctionDef function = 1; + { + unsigned int count = this->function_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->function(i)); + } + } + + // repeated .tensorflow.GradientDef gradient = 2; + { + unsigned int count = this->gradient_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->gradient(i)); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FunctionDefLibrary::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.FunctionDefLibrary) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const FunctionDefLibrary* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.FunctionDefLibrary) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.FunctionDefLibrary) + UnsafeMergeFrom(*source); + } +} + +void FunctionDefLibrary::MergeFrom(const FunctionDefLibrary& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.FunctionDefLibrary) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void FunctionDefLibrary::UnsafeMergeFrom(const FunctionDefLibrary& from) { + GOOGLE_DCHECK(&from != this); + function_.MergeFrom(from.function_); + gradient_.MergeFrom(from.gradient_); +} + +void FunctionDefLibrary::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.FunctionDefLibrary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionDefLibrary::CopyFrom(const FunctionDefLibrary& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.FunctionDefLibrary) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool FunctionDefLibrary::IsInitialized() const { + + return true; +} + +void FunctionDefLibrary::Swap(FunctionDefLibrary* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + FunctionDefLibrary temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void FunctionDefLibrary::UnsafeArenaSwap(FunctionDefLibrary* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void FunctionDefLibrary::InternalSwap(FunctionDefLibrary* other) { + function_.UnsafeArenaSwap(&other->function_); + gradient_.UnsafeArenaSwap(&other->gradient_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata FunctionDefLibrary::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FunctionDefLibrary_descriptor_; + metadata.reflection = FunctionDefLibrary_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// FunctionDefLibrary + +// repeated .tensorflow.FunctionDef function = 1; +int FunctionDefLibrary::function_size() const { + return function_.size(); +} +void FunctionDefLibrary::clear_function() { + function_.Clear(); +} +const ::tensorflow::FunctionDef& FunctionDefLibrary::function(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDefLibrary.function) + return function_.Get(index); +} +::tensorflow::FunctionDef* FunctionDefLibrary::mutable_function(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDefLibrary.function) + return function_.Mutable(index); +} +::tensorflow::FunctionDef* FunctionDefLibrary::add_function() { + // @@protoc_insertion_point(field_add:tensorflow.FunctionDefLibrary.function) + return function_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef >* +FunctionDefLibrary::mutable_function() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDefLibrary.function) + return &function_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef >& +FunctionDefLibrary::function() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDefLibrary.function) + return function_; +} + +// repeated .tensorflow.GradientDef gradient = 2; +int FunctionDefLibrary::gradient_size() const { + return gradient_.size(); +} +void FunctionDefLibrary::clear_gradient() { + gradient_.Clear(); +} +const ::tensorflow::GradientDef& FunctionDefLibrary::gradient(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDefLibrary.gradient) + return gradient_.Get(index); +} +::tensorflow::GradientDef* FunctionDefLibrary::mutable_gradient(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDefLibrary.gradient) + return gradient_.Mutable(index); +} +::tensorflow::GradientDef* FunctionDefLibrary::add_gradient() { + // @@protoc_insertion_point(field_add:tensorflow.FunctionDefLibrary.gradient) + return gradient_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::GradientDef >* +FunctionDefLibrary::mutable_gradient() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDefLibrary.gradient) + return &gradient_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::GradientDef >& +FunctionDefLibrary::gradient() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDefLibrary.gradient) + return gradient_; +} + +inline const FunctionDefLibrary* FunctionDefLibrary::internal_default_instance() { + return &FunctionDefLibrary_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int FunctionDef_Node::kRetFieldNumber; +const int FunctionDef_Node::kOpFieldNumber; +const int FunctionDef_Node::kArgFieldNumber; +const int FunctionDef_Node::kDepFieldNumber; +const int FunctionDef_Node::kAttrFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +FunctionDef_Node::FunctionDef_Node() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_function_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.FunctionDef.Node) +} +FunctionDef_Node::FunctionDef_Node(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + ret_(arena), + arg_(arena), + dep_(arena), + attr_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_function_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.FunctionDef.Node) +} + +void FunctionDef_Node::InitAsDefaultInstance() { +} + +FunctionDef_Node::FunctionDef_Node(const FunctionDef_Node& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.FunctionDef.Node) +} + +void FunctionDef_Node::SharedCtor() { + attr_.SetAssignDescriptorCallback( + protobuf_AssignDescriptorsOnce); + attr_.SetEntryDescriptor( + &::tensorflow::FunctionDef_Node_AttrEntry_descriptor_); + op_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + _cached_size_ = 0; +} + +FunctionDef_Node::~FunctionDef_Node() { + // @@protoc_insertion_point(destructor:tensorflow.FunctionDef.Node) + SharedDtor(); +} + +void FunctionDef_Node::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + op_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); +} + +void FunctionDef_Node::ArenaDtor(void* object) { + FunctionDef_Node* _this = reinterpret_cast< FunctionDef_Node* >(object); + (void)_this; +} +void FunctionDef_Node::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void FunctionDef_Node::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FunctionDef_Node::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FunctionDef_Node_descriptor_; +} + +const FunctionDef_Node& FunctionDef_Node::default_instance() { + protobuf_InitDefaults_function_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed FunctionDef_Node_default_instance_; + +FunctionDef_Node* FunctionDef_Node::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void FunctionDef_Node::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.FunctionDef.Node) + op_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + ret_.Clear(); + arg_.Clear(); + dep_.Clear(); + attr_.Clear(); +} + +bool FunctionDef_Node::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.FunctionDef.Node) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string ret = 1; + case 1: { + if (tag == 10) { + parse_ret: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_ret())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ret(this->ret_size() - 1).data(), + this->ret(this->ret_size() - 1).length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.FunctionDef.Node.ret")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_ret; + if (input->ExpectTag(18)) goto parse_op; + break; + } + + // optional string op = 2; + case 2: { + if (tag == 18) { + parse_op: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_op())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->op().data(), this->op().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.FunctionDef.Node.op")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_arg; + break; + } + + // repeated string arg = 3; + case 3: { + if (tag == 26) { + parse_arg: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_arg())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->arg(this->arg_size() - 1).data(), + this->arg(this->arg_size() - 1).length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.FunctionDef.Node.arg")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_arg; + if (input->ExpectTag(34)) goto parse_dep; + break; + } + + // repeated string dep = 4; + case 4: { + if (tag == 34) { + parse_dep: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_dep())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->dep(this->dep_size() - 1).data(), + this->dep(this->dep_size() - 1).length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.FunctionDef.Node.dep")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_dep; + if (input->ExpectTag(42)) goto parse_attr; + break; + } + + // map attr = 5; + case 5: { + if (tag == 42) { + parse_attr: + DO_(input->IncrementRecursionDepth()); + parse_loop_attr: + FunctionDef_Node_AttrEntry::Parser< ::google::protobuf::internal::MapField< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 >, + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue > > parser(&attr_); + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, &parser)); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + parser.key().data(), parser.key().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.FunctionDef.Node.AttrEntry.key")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_loop_attr; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.FunctionDef.Node) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.FunctionDef.Node) + return false; +#undef DO_ +} + +void FunctionDef_Node::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.FunctionDef.Node) + // repeated string ret = 1; + for (int i = 0; i < this->ret_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ret(i).data(), this->ret(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.ret"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->ret(i), output); + } + + // optional string op = 2; + if (this->op().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->op().data(), this->op().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.op"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->op(), output); + } + + // repeated string arg = 3; + for (int i = 0; i < this->arg_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->arg(i).data(), this->arg(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.arg"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->arg(i), output); + } + + // repeated string dep = 4; + for (int i = 0; i < this->dep_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->dep(i).data(), this->dep(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.dep"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->dep(i), output); + } + + // map attr = 5; + if (!this->attr().empty()) { + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::google::protobuf::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), p->first.length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.AttrEntry.key"); + } + }; + + if (output->IsSerializationDeterminstic() && + this->attr().size() > 1) { + ::google::protobuf::scoped_array items( + new SortItem[this->attr().size()]); + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::size_type size_type; + size_type n = 0; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it, ++n) { + items[n] = SortItem(&*it); + } + ::std::sort(&items[0], &items[n], Less()); + ::google::protobuf::scoped_ptr entry; + for (size_type i = 0; i < n; i++) { + entry.reset(attr_.NewEntryWrapper( + items[i]->first, items[i]->second)); + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *entry, output); + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(items[i]); + } + } else { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + entry.reset(attr_.NewEntryWrapper( + it->first, it->second)); + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *entry, output); + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(&*it); + } + } + } + + // @@protoc_insertion_point(serialize_end:tensorflow.FunctionDef.Node) +} + +::google::protobuf::uint8* FunctionDef_Node::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.FunctionDef.Node) + // repeated string ret = 1; + for (int i = 0; i < this->ret_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ret(i).data(), this->ret(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.ret"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->ret(i), target); + } + + // optional string op = 2; + if (this->op().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->op().data(), this->op().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.op"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->op(), target); + } + + // repeated string arg = 3; + for (int i = 0; i < this->arg_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->arg(i).data(), this->arg(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.arg"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->arg(i), target); + } + + // repeated string dep = 4; + for (int i = 0; i < this->dep_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->dep(i).data(), this->dep(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.dep"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(4, this->dep(i), target); + } + + // map attr = 5; + if (!this->attr().empty()) { + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::google::protobuf::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), p->first.length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.FunctionDef.Node.AttrEntry.key"); + } + }; + + if (deterministic && + this->attr().size() > 1) { + ::google::protobuf::scoped_array items( + new SortItem[this->attr().size()]); + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::size_type size_type; + size_type n = 0; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it, ++n) { + items[n] = SortItem(&*it); + } + ::std::sort(&items[0], &items[n], Less()); + ::google::protobuf::scoped_ptr entry; + for (size_type i = 0; i < n; i++) { + entry.reset(attr_.NewEntryWrapper( + items[i]->first, items[i]->second)); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *entry, deterministic, target); +; + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(items[i]); + } + } else { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + entry.reset(attr_.NewEntryWrapper( + it->first, it->second)); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *entry, deterministic, target); +; + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(&*it); + } + } + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.FunctionDef.Node) + return target; +} + +size_t FunctionDef_Node::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.FunctionDef.Node) + size_t total_size = 0; + + // optional string op = 2; + if (this->op().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->op()); + } + + // repeated string ret = 1; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->ret_size()); + for (int i = 0; i < this->ret_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->ret(i)); + } + + // repeated string arg = 3; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->arg_size()); + for (int i = 0; i < this->arg_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->arg(i)); + } + + // repeated string dep = 4; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->dep_size()); + for (int i = 0; i < this->dep_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->dep(i)); + } + + // map attr = 5; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->attr_size()); + { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + if (entry.get() != NULL && entry->GetArena() != NULL) { + entry.release(); + } + entry.reset(attr_.NewEntryWrapper(it->first, it->second)); + total_size += ::google::protobuf::internal::WireFormatLite:: + MessageSizeNoVirtual(*entry); + } + if (entry.get() != NULL && entry->GetArena() != NULL) { + entry.release(); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FunctionDef_Node::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.FunctionDef.Node) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const FunctionDef_Node* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.FunctionDef.Node) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.FunctionDef.Node) + UnsafeMergeFrom(*source); + } +} + +void FunctionDef_Node::MergeFrom(const FunctionDef_Node& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.FunctionDef.Node) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void FunctionDef_Node::UnsafeMergeFrom(const FunctionDef_Node& from) { + GOOGLE_DCHECK(&from != this); + ret_.UnsafeMergeFrom(from.ret_); + arg_.UnsafeMergeFrom(from.arg_); + dep_.UnsafeMergeFrom(from.dep_); + attr_.MergeFrom(from.attr_); + if (from.op().size() > 0) { + set_op(from.op()); + } +} + +void FunctionDef_Node::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.FunctionDef.Node) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionDef_Node::CopyFrom(const FunctionDef_Node& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.FunctionDef.Node) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool FunctionDef_Node::IsInitialized() const { + + return true; +} + +void FunctionDef_Node::Swap(FunctionDef_Node* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + FunctionDef_Node temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void FunctionDef_Node::UnsafeArenaSwap(FunctionDef_Node* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void FunctionDef_Node::InternalSwap(FunctionDef_Node* other) { + ret_.UnsafeArenaSwap(&other->ret_); + op_.Swap(&other->op_); + arg_.UnsafeArenaSwap(&other->arg_); + dep_.UnsafeArenaSwap(&other->dep_); + attr_.Swap(&other->attr_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata FunctionDef_Node::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FunctionDef_Node_descriptor_; + metadata.reflection = FunctionDef_Node_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +void FunctionDef::_slow_mutable_signature() { + signature_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::OpDef >( + GetArenaNoVirtual()); +} +::tensorflow::OpDef* FunctionDef::_slow_release_signature() { + if (signature_ == NULL) { + return NULL; + } else { + ::tensorflow::OpDef* temp = new ::tensorflow::OpDef(*signature_); + signature_ = NULL; + return temp; + } +} +::tensorflow::OpDef* FunctionDef::unsafe_arena_release_signature() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.FunctionDef.signature) + + ::tensorflow::OpDef* temp = signature_; + signature_ = NULL; + return temp; +} +void FunctionDef::_slow_set_allocated_signature( + ::google::protobuf::Arena* message_arena, ::tensorflow::OpDef** signature) { + if (message_arena != NULL && + ::google::protobuf::Arena::GetArena(*signature) == NULL) { + message_arena->Own(*signature); + } else if (message_arena != + ::google::protobuf::Arena::GetArena(*signature)) { + ::tensorflow::OpDef* new_signature = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::OpDef >( + message_arena); + new_signature->CopyFrom(**signature); + *signature = new_signature; + } +} +void FunctionDef::unsafe_arena_set_allocated_signature( + ::tensorflow::OpDef* signature) { + if (GetArenaNoVirtual() == NULL) { + delete signature_; + } + signature_ = signature; + if (signature) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FunctionDef.signature) +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int FunctionDef::kSignatureFieldNumber; +const int FunctionDef::kNodeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +FunctionDef::FunctionDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_function_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.FunctionDef) +} +FunctionDef::FunctionDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + node_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_function_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.FunctionDef) +} + +void FunctionDef::InitAsDefaultInstance() { + signature_ = const_cast< ::tensorflow::OpDef*>( + ::tensorflow::OpDef::internal_default_instance()); +} + +FunctionDef::FunctionDef(const FunctionDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.FunctionDef) +} + +void FunctionDef::SharedCtor() { + signature_ = NULL; + _cached_size_ = 0; +} + +FunctionDef::~FunctionDef() { + // @@protoc_insertion_point(destructor:tensorflow.FunctionDef) + SharedDtor(); +} + +void FunctionDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + if (this != &FunctionDef_default_instance_.get()) { + delete signature_; + } +} + +void FunctionDef::ArenaDtor(void* object) { + FunctionDef* _this = reinterpret_cast< FunctionDef* >(object); + (void)_this; +} +void FunctionDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void FunctionDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FunctionDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FunctionDef_descriptor_; +} + +const FunctionDef& FunctionDef::default_instance() { + protobuf_InitDefaults_function_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed FunctionDef_default_instance_; + +FunctionDef* FunctionDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void FunctionDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.FunctionDef) + if (GetArenaNoVirtual() == NULL && signature_ != NULL) delete signature_; + signature_ = NULL; + node_.Clear(); +} + +bool FunctionDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.FunctionDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .tensorflow.OpDef signature = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_signature())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_node; + break; + } + + // repeated .tensorflow.FunctionDef.Node node = 2; + case 2: { + if (tag == 18) { + parse_node: + DO_(input->IncrementRecursionDepth()); + parse_loop_node: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_node())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_loop_node; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.FunctionDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.FunctionDef) + return false; +#undef DO_ +} + +void FunctionDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.FunctionDef) + // optional .tensorflow.OpDef signature = 1; + if (this->has_signature()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, *this->signature_, output); + } + + // repeated .tensorflow.FunctionDef.Node node = 2; + for (unsigned int i = 0, n = this->node_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->node(i), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.FunctionDef) +} + +::google::protobuf::uint8* FunctionDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.FunctionDef) + // optional .tensorflow.OpDef signature = 1; + if (this->has_signature()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, *this->signature_, false, target); + } + + // repeated .tensorflow.FunctionDef.Node node = 2; + for (unsigned int i = 0, n = this->node_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, this->node(i), false, target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.FunctionDef) + return target; +} + +size_t FunctionDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.FunctionDef) + size_t total_size = 0; + + // optional .tensorflow.OpDef signature = 1; + if (this->has_signature()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->signature_); + } + + // repeated .tensorflow.FunctionDef.Node node = 2; + { + unsigned int count = this->node_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->node(i)); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FunctionDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.FunctionDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const FunctionDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.FunctionDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.FunctionDef) + UnsafeMergeFrom(*source); + } +} + +void FunctionDef::MergeFrom(const FunctionDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.FunctionDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void FunctionDef::UnsafeMergeFrom(const FunctionDef& from) { + GOOGLE_DCHECK(&from != this); + node_.MergeFrom(from.node_); + if (from.has_signature()) { + mutable_signature()->::tensorflow::OpDef::MergeFrom(from.signature()); + } +} + +void FunctionDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.FunctionDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionDef::CopyFrom(const FunctionDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.FunctionDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool FunctionDef::IsInitialized() const { + + return true; +} + +void FunctionDef::Swap(FunctionDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + FunctionDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void FunctionDef::UnsafeArenaSwap(FunctionDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void FunctionDef::InternalSwap(FunctionDef* other) { + std::swap(signature_, other->signature_); + node_.UnsafeArenaSwap(&other->node_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata FunctionDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FunctionDef_descriptor_; + metadata.reflection = FunctionDef_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// FunctionDef_Node + +// repeated string ret = 1; +int FunctionDef_Node::ret_size() const { + return ret_.size(); +} +void FunctionDef_Node::clear_ret() { + ret_.Clear(); +} +const ::std::string& FunctionDef_Node::ret(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.ret) + return ret_.Get(index); +} +::std::string* FunctionDef_Node::mutable_ret(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.ret) + return ret_.Mutable(index); +} +void FunctionDef_Node::set_ret(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.ret) + ret_.Mutable(index)->assign(value); +} +void FunctionDef_Node::set_ret(int index, const char* value) { + ret_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.ret) +} +void FunctionDef_Node::set_ret(int index, const char* value, size_t size) { + ret_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.ret) +} +::std::string* FunctionDef_Node::add_ret() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.FunctionDef.Node.ret) + return ret_.Add(); +} +void FunctionDef_Node::add_ret(const ::std::string& value) { + ret_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.Node.ret) +} +void FunctionDef_Node::add_ret(const char* value) { + ret_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.FunctionDef.Node.ret) +} +void FunctionDef_Node::add_ret(const char* value, size_t size) { + ret_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.FunctionDef.Node.ret) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +FunctionDef_Node::ret() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.Node.ret) + return ret_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +FunctionDef_Node::mutable_ret() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.Node.ret) + return &ret_; +} + +// optional string op = 2; +void FunctionDef_Node::clear_op() { + op_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& FunctionDef_Node::op() const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.op) + return op_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void FunctionDef_Node::set_op(const ::std::string& value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.op) +} +void FunctionDef_Node::set_op(const char* value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.op) +} +void FunctionDef_Node::set_op(const char* value, + size_t size) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.op) +} +::std::string* FunctionDef_Node::mutable_op() { + + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.op) + return op_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* FunctionDef_Node::release_op() { + // @@protoc_insertion_point(field_release:tensorflow.FunctionDef.Node.op) + + return op_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* FunctionDef_Node::unsafe_arena_release_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.FunctionDef.Node.op) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return op_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void FunctionDef_Node::set_allocated_op(::std::string* op) { + if (op != NULL) { + + } else { + + } + op_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), op, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.FunctionDef.Node.op) +} +void FunctionDef_Node::unsafe_arena_set_allocated_op( + ::std::string* op) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (op != NULL) { + + } else { + + } + op_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + op, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FunctionDef.Node.op) +} + +// repeated string arg = 3; +int FunctionDef_Node::arg_size() const { + return arg_.size(); +} +void FunctionDef_Node::clear_arg() { + arg_.Clear(); +} +const ::std::string& FunctionDef_Node::arg(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.arg) + return arg_.Get(index); +} +::std::string* FunctionDef_Node::mutable_arg(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.arg) + return arg_.Mutable(index); +} +void FunctionDef_Node::set_arg(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.arg) + arg_.Mutable(index)->assign(value); +} +void FunctionDef_Node::set_arg(int index, const char* value) { + arg_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.arg) +} +void FunctionDef_Node::set_arg(int index, const char* value, size_t size) { + arg_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.arg) +} +::std::string* FunctionDef_Node::add_arg() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.FunctionDef.Node.arg) + return arg_.Add(); +} +void FunctionDef_Node::add_arg(const ::std::string& value) { + arg_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.Node.arg) +} +void FunctionDef_Node::add_arg(const char* value) { + arg_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.FunctionDef.Node.arg) +} +void FunctionDef_Node::add_arg(const char* value, size_t size) { + arg_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.FunctionDef.Node.arg) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +FunctionDef_Node::arg() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.Node.arg) + return arg_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +FunctionDef_Node::mutable_arg() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.Node.arg) + return &arg_; +} + +// repeated string dep = 4; +int FunctionDef_Node::dep_size() const { + return dep_.size(); +} +void FunctionDef_Node::clear_dep() { + dep_.Clear(); +} +const ::std::string& FunctionDef_Node::dep(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.dep) + return dep_.Get(index); +} +::std::string* FunctionDef_Node::mutable_dep(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.dep) + return dep_.Mutable(index); +} +void FunctionDef_Node::set_dep(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.dep) + dep_.Mutable(index)->assign(value); +} +void FunctionDef_Node::set_dep(int index, const char* value) { + dep_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.dep) +} +void FunctionDef_Node::set_dep(int index, const char* value, size_t size) { + dep_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.dep) +} +::std::string* FunctionDef_Node::add_dep() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.FunctionDef.Node.dep) + return dep_.Add(); +} +void FunctionDef_Node::add_dep(const ::std::string& value) { + dep_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.Node.dep) +} +void FunctionDef_Node::add_dep(const char* value) { + dep_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.FunctionDef.Node.dep) +} +void FunctionDef_Node::add_dep(const char* value, size_t size) { + dep_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.FunctionDef.Node.dep) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +FunctionDef_Node::dep() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.Node.dep) + return dep_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +FunctionDef_Node::mutable_dep() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.Node.dep) + return &dep_; +} + +// map attr = 5; +int FunctionDef_Node::attr_size() const { + return attr_.size(); +} +void FunctionDef_Node::clear_attr() { + attr_.Clear(); +} + const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& +FunctionDef_Node::attr() const { + // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.Node.attr) + return attr_.GetMap(); +} + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* +FunctionDef_Node::mutable_attr() { + // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.Node.attr) + return attr_.MutableMap(); +} + +inline const FunctionDef_Node* FunctionDef_Node::internal_default_instance() { + return &FunctionDef_Node_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// FunctionDef + +// optional .tensorflow.OpDef signature = 1; +bool FunctionDef::has_signature() const { + return this != internal_default_instance() && signature_ != NULL; +} +void FunctionDef::clear_signature() { + if (GetArenaNoVirtual() == NULL && signature_ != NULL) delete signature_; + signature_ = NULL; +} +const ::tensorflow::OpDef& FunctionDef::signature() const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.signature) + return signature_ != NULL ? *signature_ + : *::tensorflow::OpDef::internal_default_instance(); +} +::tensorflow::OpDef* FunctionDef::mutable_signature() { + + if (signature_ == NULL) { + _slow_mutable_signature(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.signature) + return signature_; +} +::tensorflow::OpDef* FunctionDef::release_signature() { + // @@protoc_insertion_point(field_release:tensorflow.FunctionDef.signature) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_signature(); + } else { + ::tensorflow::OpDef* temp = signature_; + signature_ = NULL; + return temp; + } +} + void FunctionDef::set_allocated_signature(::tensorflow::OpDef* signature) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete signature_; + } + if (signature != NULL) { + _slow_set_allocated_signature(message_arena, &signature); + } + signature_ = signature; + if (signature) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.FunctionDef.signature) +} + +// repeated .tensorflow.FunctionDef.Node node = 2; +int FunctionDef::node_size() const { + return node_.size(); +} +void FunctionDef::clear_node() { + node_.Clear(); +} +const ::tensorflow::FunctionDef_Node& FunctionDef::node(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.node) + return node_.Get(index); +} +::tensorflow::FunctionDef_Node* FunctionDef::mutable_node(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.node) + return node_.Mutable(index); +} +::tensorflow::FunctionDef_Node* FunctionDef::add_node() { + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.node) + return node_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef_Node >* +FunctionDef::mutable_node() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.node) + return &node_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef_Node >& +FunctionDef::node() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.node) + return node_; +} + +inline const FunctionDef* FunctionDef::internal_default_instance() { + return &FunctionDef_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int GradientDef::kFunctionNameFieldNumber; +const int GradientDef::kGradientFuncFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +GradientDef::GradientDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_function_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.GradientDef) +} +GradientDef::GradientDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_function_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.GradientDef) +} + +void GradientDef::InitAsDefaultInstance() { +} + +GradientDef::GradientDef(const GradientDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.GradientDef) +} + +void GradientDef::SharedCtor() { + function_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + gradient_func_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + _cached_size_ = 0; +} + +GradientDef::~GradientDef() { + // @@protoc_insertion_point(destructor:tensorflow.GradientDef) + SharedDtor(); +} + +void GradientDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + function_name_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + gradient_func_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); +} + +void GradientDef::ArenaDtor(void* object) { + GradientDef* _this = reinterpret_cast< GradientDef* >(object); + (void)_this; +} +void GradientDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void GradientDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GradientDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GradientDef_descriptor_; +} + +const GradientDef& GradientDef::default_instance() { + protobuf_InitDefaults_function_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed GradientDef_default_instance_; + +GradientDef* GradientDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void GradientDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.GradientDef) + function_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + gradient_func_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} + +bool GradientDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.GradientDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string function_name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_function_name())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->function_name().data(), this->function_name().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.GradientDef.function_name")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_gradient_func; + break; + } + + // optional string gradient_func = 2; + case 2: { + if (tag == 18) { + parse_gradient_func: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_gradient_func())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->gradient_func().data(), this->gradient_func().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.GradientDef.gradient_func")); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.GradientDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.GradientDef) + return false; +#undef DO_ +} + +void GradientDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.GradientDef) + // optional string function_name = 1; + if (this->function_name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->function_name().data(), this->function_name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.GradientDef.function_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->function_name(), output); + } + + // optional string gradient_func = 2; + if (this->gradient_func().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->gradient_func().data(), this->gradient_func().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.GradientDef.gradient_func"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->gradient_func(), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.GradientDef) +} + +::google::protobuf::uint8* GradientDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GradientDef) + // optional string function_name = 1; + if (this->function_name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->function_name().data(), this->function_name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.GradientDef.function_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->function_name(), target); + } + + // optional string gradient_func = 2; + if (this->gradient_func().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->gradient_func().data(), this->gradient_func().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.GradientDef.gradient_func"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->gradient_func(), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GradientDef) + return target; +} + +size_t GradientDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.GradientDef) + size_t total_size = 0; + + // optional string function_name = 1; + if (this->function_name().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->function_name()); + } + + // optional string gradient_func = 2; + if (this->gradient_func().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->gradient_func()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GradientDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.GradientDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const GradientDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.GradientDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.GradientDef) + UnsafeMergeFrom(*source); + } +} + +void GradientDef::MergeFrom(const GradientDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GradientDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void GradientDef::UnsafeMergeFrom(const GradientDef& from) { + GOOGLE_DCHECK(&from != this); + if (from.function_name().size() > 0) { + set_function_name(from.function_name()); + } + if (from.gradient_func().size() > 0) { + set_gradient_func(from.gradient_func()); + } +} + +void GradientDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.GradientDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GradientDef::CopyFrom(const GradientDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GradientDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool GradientDef::IsInitialized() const { + + return true; +} + +void GradientDef::Swap(GradientDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + GradientDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void GradientDef::UnsafeArenaSwap(GradientDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void GradientDef::InternalSwap(GradientDef* other) { + function_name_.Swap(&other->function_name_); + gradient_func_.Swap(&other->gradient_func_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata GradientDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GradientDef_descriptor_; + metadata.reflection = GradientDef_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// GradientDef + +// optional string function_name = 1; +void GradientDef::clear_function_name() { + function_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& GradientDef::function_name() const { + // @@protoc_insertion_point(field_get:tensorflow.GradientDef.function_name) + return function_name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void GradientDef::set_function_name(const ::std::string& value) { + + function_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.GradientDef.function_name) +} +void GradientDef::set_function_name(const char* value) { + + function_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.GradientDef.function_name) +} +void GradientDef::set_function_name(const char* value, + size_t size) { + + function_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.GradientDef.function_name) +} +::std::string* GradientDef::mutable_function_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.GradientDef.function_name) + return function_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* GradientDef::release_function_name() { + // @@protoc_insertion_point(field_release:tensorflow.GradientDef.function_name) + + return function_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* GradientDef::unsafe_arena_release_function_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GradientDef.function_name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return function_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void GradientDef::set_allocated_function_name(::std::string* function_name) { + if (function_name != NULL) { + + } else { + + } + function_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), function_name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.GradientDef.function_name) +} +void GradientDef::unsafe_arena_set_allocated_function_name( + ::std::string* function_name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (function_name != NULL) { + + } else { + + } + function_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + function_name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GradientDef.function_name) +} + +// optional string gradient_func = 2; +void GradientDef::clear_gradient_func() { + gradient_func_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& GradientDef::gradient_func() const { + // @@protoc_insertion_point(field_get:tensorflow.GradientDef.gradient_func) + return gradient_func_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void GradientDef::set_gradient_func(const ::std::string& value) { + + gradient_func_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.GradientDef.gradient_func) +} +void GradientDef::set_gradient_func(const char* value) { + + gradient_func_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.GradientDef.gradient_func) +} +void GradientDef::set_gradient_func(const char* value, + size_t size) { + + gradient_func_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.GradientDef.gradient_func) +} +::std::string* GradientDef::mutable_gradient_func() { + + // @@protoc_insertion_point(field_mutable:tensorflow.GradientDef.gradient_func) + return gradient_func_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* GradientDef::release_gradient_func() { + // @@protoc_insertion_point(field_release:tensorflow.GradientDef.gradient_func) + + return gradient_func_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* GradientDef::unsafe_arena_release_gradient_func() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GradientDef.gradient_func) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return gradient_func_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void GradientDef::set_allocated_gradient_func(::std::string* gradient_func) { + if (gradient_func != NULL) { + + } else { + + } + gradient_func_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), gradient_func, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.GradientDef.gradient_func) +} +void GradientDef::unsafe_arena_set_allocated_gradient_func( + ::std::string* gradient_func) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (gradient_func != NULL) { + + } else { + + } + gradient_func_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + gradient_func, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GradientDef.gradient_func) +} + +inline const GradientDef* GradientDef::internal_default_instance() { + return &GradientDef_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/function.pb.h b/modules/dnn/misc/tensorflow/function.pb.h new file mode 100644 index 0000000000..3f89687b61 --- /dev/null +++ b/modules/dnn/misc/tensorflow/function.pb.h @@ -0,0 +1,1160 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: function.proto + +#ifndef PROTOBUF_function_2eproto__INCLUDED +#define PROTOBUF_function_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "attr_value.pb.h" +#include "op_def.pb.h" +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_function_2eproto(); +void protobuf_InitDefaults_function_2eproto(); +void protobuf_AssignDesc_function_2eproto(); +void protobuf_ShutdownFile_function_2eproto(); + +class FunctionDef; +class FunctionDefLibrary; +class FunctionDef_Node; +class GradientDef; + +// =================================================================== + +class FunctionDefLibrary : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.FunctionDefLibrary) */ { + public: + FunctionDefLibrary(); + virtual ~FunctionDefLibrary(); + + FunctionDefLibrary(const FunctionDefLibrary& from); + + inline FunctionDefLibrary& operator=(const FunctionDefLibrary& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const FunctionDefLibrary& default_instance(); + + static const FunctionDefLibrary* internal_default_instance(); + + void UnsafeArenaSwap(FunctionDefLibrary* other); + void Swap(FunctionDefLibrary* other); + + // implements Message ---------------------------------------------- + + inline FunctionDefLibrary* New() const { return New(NULL); } + + FunctionDefLibrary* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FunctionDefLibrary& from); + void MergeFrom(const FunctionDefLibrary& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FunctionDefLibrary* other); + void UnsafeMergeFrom(const FunctionDefLibrary& from); + protected: + explicit FunctionDefLibrary(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .tensorflow.FunctionDef function = 1; + int function_size() const; + void clear_function(); + static const int kFunctionFieldNumber = 1; + const ::tensorflow::FunctionDef& function(int index) const; + ::tensorflow::FunctionDef* mutable_function(int index); + ::tensorflow::FunctionDef* add_function(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef >* + mutable_function(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef >& + function() const; + + // repeated .tensorflow.GradientDef gradient = 2; + int gradient_size() const; + void clear_gradient(); + static const int kGradientFieldNumber = 2; + const ::tensorflow::GradientDef& gradient(int index) const; + ::tensorflow::GradientDef* mutable_gradient(int index); + ::tensorflow::GradientDef* add_gradient(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::GradientDef >* + mutable_gradient(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::GradientDef >& + gradient() const; + + // @@protoc_insertion_point(class_scope:tensorflow.FunctionDefLibrary) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef > function_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::GradientDef > gradient_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_function_2eproto_impl(); + friend void protobuf_AddDesc_function_2eproto_impl(); + friend void protobuf_AssignDesc_function_2eproto(); + friend void protobuf_ShutdownFile_function_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed FunctionDefLibrary_default_instance_; + +// ------------------------------------------------------------------- + +class FunctionDef_Node : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.FunctionDef.Node) */ { + public: + FunctionDef_Node(); + virtual ~FunctionDef_Node(); + + FunctionDef_Node(const FunctionDef_Node& from); + + inline FunctionDef_Node& operator=(const FunctionDef_Node& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const FunctionDef_Node& default_instance(); + + static const FunctionDef_Node* internal_default_instance(); + + void UnsafeArenaSwap(FunctionDef_Node* other); + void Swap(FunctionDef_Node* other); + + // implements Message ---------------------------------------------- + + inline FunctionDef_Node* New() const { return New(NULL); } + + FunctionDef_Node* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FunctionDef_Node& from); + void MergeFrom(const FunctionDef_Node& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FunctionDef_Node* other); + void UnsafeMergeFrom(const FunctionDef_Node& from); + protected: + explicit FunctionDef_Node(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + + // accessors ------------------------------------------------------- + + // repeated string ret = 1; + int ret_size() const; + void clear_ret(); + static const int kRetFieldNumber = 1; + const ::std::string& ret(int index) const; + ::std::string* mutable_ret(int index); + void set_ret(int index, const ::std::string& value); + void set_ret(int index, const char* value); + void set_ret(int index, const char* value, size_t size); + ::std::string* add_ret(); + void add_ret(const ::std::string& value); + void add_ret(const char* value); + void add_ret(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& ret() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_ret(); + + // optional string op = 2; + void clear_op(); + static const int kOpFieldNumber = 2; + const ::std::string& op() const; + void set_op(const ::std::string& value); + void set_op(const char* value); + void set_op(const char* value, size_t size); + ::std::string* mutable_op(); + ::std::string* release_op(); + void set_allocated_op(::std::string* op); + ::std::string* unsafe_arena_release_op(); + void unsafe_arena_set_allocated_op( + ::std::string* op); + + // repeated string arg = 3; + int arg_size() const; + void clear_arg(); + static const int kArgFieldNumber = 3; + const ::std::string& arg(int index) const; + ::std::string* mutable_arg(int index); + void set_arg(int index, const ::std::string& value); + void set_arg(int index, const char* value); + void set_arg(int index, const char* value, size_t size); + ::std::string* add_arg(); + void add_arg(const ::std::string& value); + void add_arg(const char* value); + void add_arg(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& arg() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_arg(); + + // repeated string dep = 4; + int dep_size() const; + void clear_dep(); + static const int kDepFieldNumber = 4; + const ::std::string& dep(int index) const; + ::std::string* mutable_dep(int index); + void set_dep(int index, const ::std::string& value); + void set_dep(int index, const char* value); + void set_dep(int index, const char* value, size_t size); + ::std::string* add_dep(); + void add_dep(const ::std::string& value); + void add_dep(const char* value); + void add_dep(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& dep() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_dep(); + + // map attr = 5; + int attr_size() const; + void clear_attr(); + static const int kAttrFieldNumber = 5; + const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& + attr() const; + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* + mutable_attr(); + + // @@protoc_insertion_point(class_scope:tensorflow.FunctionDef.Node) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::std::string> ret_; + ::google::protobuf::RepeatedPtrField< ::std::string> arg_; + ::google::protobuf::RepeatedPtrField< ::std::string> dep_; + typedef ::google::protobuf::internal::MapEntryLite< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 > + FunctionDef_Node_AttrEntry; + ::google::protobuf::internal::MapField< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 > attr_; + ::google::protobuf::internal::ArenaStringPtr op_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_function_2eproto_impl(); + friend void protobuf_AddDesc_function_2eproto_impl(); + friend void protobuf_AssignDesc_function_2eproto(); + friend void protobuf_ShutdownFile_function_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed FunctionDef_Node_default_instance_; + +// ------------------------------------------------------------------- + +class FunctionDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.FunctionDef) */ { + public: + FunctionDef(); + virtual ~FunctionDef(); + + FunctionDef(const FunctionDef& from); + + inline FunctionDef& operator=(const FunctionDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const FunctionDef& default_instance(); + + static const FunctionDef* internal_default_instance(); + + void UnsafeArenaSwap(FunctionDef* other); + void Swap(FunctionDef* other); + + // implements Message ---------------------------------------------- + + inline FunctionDef* New() const { return New(NULL); } + + FunctionDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FunctionDef& from); + void MergeFrom(const FunctionDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FunctionDef* other); + void UnsafeMergeFrom(const FunctionDef& from); + protected: + explicit FunctionDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef FunctionDef_Node Node; + + // accessors ------------------------------------------------------- + + // optional .tensorflow.OpDef signature = 1; + bool has_signature() const; + void clear_signature(); + static const int kSignatureFieldNumber = 1; + private: + void _slow_mutable_signature(); + void _slow_set_allocated_signature( + ::google::protobuf::Arena* message_arena, ::tensorflow::OpDef** signature); + ::tensorflow::OpDef* _slow_release_signature(); + public: + const ::tensorflow::OpDef& signature() const; + ::tensorflow::OpDef* mutable_signature(); + ::tensorflow::OpDef* release_signature(); + void set_allocated_signature(::tensorflow::OpDef* signature); + ::tensorflow::OpDef* unsafe_arena_release_signature(); + void unsafe_arena_set_allocated_signature( + ::tensorflow::OpDef* signature); + + // repeated .tensorflow.FunctionDef.Node node = 2; + int node_size() const; + void clear_node(); + static const int kNodeFieldNumber = 2; + const ::tensorflow::FunctionDef_Node& node(int index) const; + ::tensorflow::FunctionDef_Node* mutable_node(int index); + ::tensorflow::FunctionDef_Node* add_node(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef_Node >* + mutable_node(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef_Node >& + node() const; + + // @@protoc_insertion_point(class_scope:tensorflow.FunctionDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef_Node > node_; + ::tensorflow::OpDef* signature_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_function_2eproto_impl(); + friend void protobuf_AddDesc_function_2eproto_impl(); + friend void protobuf_AssignDesc_function_2eproto(); + friend void protobuf_ShutdownFile_function_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed FunctionDef_default_instance_; + +// ------------------------------------------------------------------- + +class GradientDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.GradientDef) */ { + public: + GradientDef(); + virtual ~GradientDef(); + + GradientDef(const GradientDef& from); + + inline GradientDef& operator=(const GradientDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const GradientDef& default_instance(); + + static const GradientDef* internal_default_instance(); + + void UnsafeArenaSwap(GradientDef* other); + void Swap(GradientDef* other); + + // implements Message ---------------------------------------------- + + inline GradientDef* New() const { return New(NULL); } + + GradientDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GradientDef& from); + void MergeFrom(const GradientDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(GradientDef* other); + void UnsafeMergeFrom(const GradientDef& from); + protected: + explicit GradientDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string function_name = 1; + void clear_function_name(); + static const int kFunctionNameFieldNumber = 1; + const ::std::string& function_name() const; + void set_function_name(const ::std::string& value); + void set_function_name(const char* value); + void set_function_name(const char* value, size_t size); + ::std::string* mutable_function_name(); + ::std::string* release_function_name(); + void set_allocated_function_name(::std::string* function_name); + ::std::string* unsafe_arena_release_function_name(); + void unsafe_arena_set_allocated_function_name( + ::std::string* function_name); + + // optional string gradient_func = 2; + void clear_gradient_func(); + static const int kGradientFuncFieldNumber = 2; + const ::std::string& gradient_func() const; + void set_gradient_func(const ::std::string& value); + void set_gradient_func(const char* value); + void set_gradient_func(const char* value, size_t size); + ::std::string* mutable_gradient_func(); + ::std::string* release_gradient_func(); + void set_allocated_gradient_func(::std::string* gradient_func); + ::std::string* unsafe_arena_release_gradient_func(); + void unsafe_arena_set_allocated_gradient_func( + ::std::string* gradient_func); + + // @@protoc_insertion_point(class_scope:tensorflow.GradientDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::internal::ArenaStringPtr function_name_; + ::google::protobuf::internal::ArenaStringPtr gradient_func_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_function_2eproto_impl(); + friend void protobuf_AddDesc_function_2eproto_impl(); + friend void protobuf_AssignDesc_function_2eproto(); + friend void protobuf_ShutdownFile_function_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed GradientDef_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// FunctionDefLibrary + +// repeated .tensorflow.FunctionDef function = 1; +inline int FunctionDefLibrary::function_size() const { + return function_.size(); +} +inline void FunctionDefLibrary::clear_function() { + function_.Clear(); +} +inline const ::tensorflow::FunctionDef& FunctionDefLibrary::function(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDefLibrary.function) + return function_.Get(index); +} +inline ::tensorflow::FunctionDef* FunctionDefLibrary::mutable_function(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDefLibrary.function) + return function_.Mutable(index); +} +inline ::tensorflow::FunctionDef* FunctionDefLibrary::add_function() { + // @@protoc_insertion_point(field_add:tensorflow.FunctionDefLibrary.function) + return function_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef >* +FunctionDefLibrary::mutable_function() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDefLibrary.function) + return &function_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef >& +FunctionDefLibrary::function() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDefLibrary.function) + return function_; +} + +// repeated .tensorflow.GradientDef gradient = 2; +inline int FunctionDefLibrary::gradient_size() const { + return gradient_.size(); +} +inline void FunctionDefLibrary::clear_gradient() { + gradient_.Clear(); +} +inline const ::tensorflow::GradientDef& FunctionDefLibrary::gradient(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDefLibrary.gradient) + return gradient_.Get(index); +} +inline ::tensorflow::GradientDef* FunctionDefLibrary::mutable_gradient(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDefLibrary.gradient) + return gradient_.Mutable(index); +} +inline ::tensorflow::GradientDef* FunctionDefLibrary::add_gradient() { + // @@protoc_insertion_point(field_add:tensorflow.FunctionDefLibrary.gradient) + return gradient_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::GradientDef >* +FunctionDefLibrary::mutable_gradient() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDefLibrary.gradient) + return &gradient_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::GradientDef >& +FunctionDefLibrary::gradient() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDefLibrary.gradient) + return gradient_; +} + +inline const FunctionDefLibrary* FunctionDefLibrary::internal_default_instance() { + return &FunctionDefLibrary_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// FunctionDef_Node + +// repeated string ret = 1; +inline int FunctionDef_Node::ret_size() const { + return ret_.size(); +} +inline void FunctionDef_Node::clear_ret() { + ret_.Clear(); +} +inline const ::std::string& FunctionDef_Node::ret(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.ret) + return ret_.Get(index); +} +inline ::std::string* FunctionDef_Node::mutable_ret(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.ret) + return ret_.Mutable(index); +} +inline void FunctionDef_Node::set_ret(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.ret) + ret_.Mutable(index)->assign(value); +} +inline void FunctionDef_Node::set_ret(int index, const char* value) { + ret_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.ret) +} +inline void FunctionDef_Node::set_ret(int index, const char* value, size_t size) { + ret_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.ret) +} +inline ::std::string* FunctionDef_Node::add_ret() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.FunctionDef.Node.ret) + return ret_.Add(); +} +inline void FunctionDef_Node::add_ret(const ::std::string& value) { + ret_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.Node.ret) +} +inline void FunctionDef_Node::add_ret(const char* value) { + ret_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.FunctionDef.Node.ret) +} +inline void FunctionDef_Node::add_ret(const char* value, size_t size) { + ret_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.FunctionDef.Node.ret) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +FunctionDef_Node::ret() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.Node.ret) + return ret_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +FunctionDef_Node::mutable_ret() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.Node.ret) + return &ret_; +} + +// optional string op = 2; +inline void FunctionDef_Node::clear_op() { + op_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& FunctionDef_Node::op() const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.op) + return op_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void FunctionDef_Node::set_op(const ::std::string& value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.op) +} +inline void FunctionDef_Node::set_op(const char* value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.op) +} +inline void FunctionDef_Node::set_op(const char* value, + size_t size) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.op) +} +inline ::std::string* FunctionDef_Node::mutable_op() { + + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.op) + return op_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* FunctionDef_Node::release_op() { + // @@protoc_insertion_point(field_release:tensorflow.FunctionDef.Node.op) + + return op_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* FunctionDef_Node::unsafe_arena_release_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.FunctionDef.Node.op) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return op_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void FunctionDef_Node::set_allocated_op(::std::string* op) { + if (op != NULL) { + + } else { + + } + op_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), op, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.FunctionDef.Node.op) +} +inline void FunctionDef_Node::unsafe_arena_set_allocated_op( + ::std::string* op) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (op != NULL) { + + } else { + + } + op_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + op, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FunctionDef.Node.op) +} + +// repeated string arg = 3; +inline int FunctionDef_Node::arg_size() const { + return arg_.size(); +} +inline void FunctionDef_Node::clear_arg() { + arg_.Clear(); +} +inline const ::std::string& FunctionDef_Node::arg(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.arg) + return arg_.Get(index); +} +inline ::std::string* FunctionDef_Node::mutable_arg(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.arg) + return arg_.Mutable(index); +} +inline void FunctionDef_Node::set_arg(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.arg) + arg_.Mutable(index)->assign(value); +} +inline void FunctionDef_Node::set_arg(int index, const char* value) { + arg_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.arg) +} +inline void FunctionDef_Node::set_arg(int index, const char* value, size_t size) { + arg_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.arg) +} +inline ::std::string* FunctionDef_Node::add_arg() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.FunctionDef.Node.arg) + return arg_.Add(); +} +inline void FunctionDef_Node::add_arg(const ::std::string& value) { + arg_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.Node.arg) +} +inline void FunctionDef_Node::add_arg(const char* value) { + arg_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.FunctionDef.Node.arg) +} +inline void FunctionDef_Node::add_arg(const char* value, size_t size) { + arg_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.FunctionDef.Node.arg) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +FunctionDef_Node::arg() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.Node.arg) + return arg_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +FunctionDef_Node::mutable_arg() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.Node.arg) + return &arg_; +} + +// repeated string dep = 4; +inline int FunctionDef_Node::dep_size() const { + return dep_.size(); +} +inline void FunctionDef_Node::clear_dep() { + dep_.Clear(); +} +inline const ::std::string& FunctionDef_Node::dep(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.Node.dep) + return dep_.Get(index); +} +inline ::std::string* FunctionDef_Node::mutable_dep(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.Node.dep) + return dep_.Mutable(index); +} +inline void FunctionDef_Node::set_dep(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.FunctionDef.Node.dep) + dep_.Mutable(index)->assign(value); +} +inline void FunctionDef_Node::set_dep(int index, const char* value) { + dep_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.FunctionDef.Node.dep) +} +inline void FunctionDef_Node::set_dep(int index, const char* value, size_t size) { + dep_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.FunctionDef.Node.dep) +} +inline ::std::string* FunctionDef_Node::add_dep() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.FunctionDef.Node.dep) + return dep_.Add(); +} +inline void FunctionDef_Node::add_dep(const ::std::string& value) { + dep_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.Node.dep) +} +inline void FunctionDef_Node::add_dep(const char* value) { + dep_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.FunctionDef.Node.dep) +} +inline void FunctionDef_Node::add_dep(const char* value, size_t size) { + dep_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.FunctionDef.Node.dep) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +FunctionDef_Node::dep() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.Node.dep) + return dep_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +FunctionDef_Node::mutable_dep() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.Node.dep) + return &dep_; +} + +// map attr = 5; +inline int FunctionDef_Node::attr_size() const { + return attr_.size(); +} +inline void FunctionDef_Node::clear_attr() { + attr_.Clear(); +} +inline const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& +FunctionDef_Node::attr() const { + // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.Node.attr) + return attr_.GetMap(); +} +inline ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* +FunctionDef_Node::mutable_attr() { + // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.Node.attr) + return attr_.MutableMap(); +} + +inline const FunctionDef_Node* FunctionDef_Node::internal_default_instance() { + return &FunctionDef_Node_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// FunctionDef + +// optional .tensorflow.OpDef signature = 1; +inline bool FunctionDef::has_signature() const { + return this != internal_default_instance() && signature_ != NULL; +} +inline void FunctionDef::clear_signature() { + if (GetArenaNoVirtual() == NULL && signature_ != NULL) delete signature_; + signature_ = NULL; +} +inline const ::tensorflow::OpDef& FunctionDef::signature() const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.signature) + return signature_ != NULL ? *signature_ + : *::tensorflow::OpDef::internal_default_instance(); +} +inline ::tensorflow::OpDef* FunctionDef::mutable_signature() { + + if (signature_ == NULL) { + _slow_mutable_signature(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.signature) + return signature_; +} +inline ::tensorflow::OpDef* FunctionDef::release_signature() { + // @@protoc_insertion_point(field_release:tensorflow.FunctionDef.signature) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_signature(); + } else { + ::tensorflow::OpDef* temp = signature_; + signature_ = NULL; + return temp; + } +} +inline void FunctionDef::set_allocated_signature(::tensorflow::OpDef* signature) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete signature_; + } + if (signature != NULL) { + _slow_set_allocated_signature(message_arena, &signature); + } + signature_ = signature; + if (signature) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.FunctionDef.signature) +} + +// repeated .tensorflow.FunctionDef.Node node = 2; +inline int FunctionDef::node_size() const { + return node_.size(); +} +inline void FunctionDef::clear_node() { + node_.Clear(); +} +inline const ::tensorflow::FunctionDef_Node& FunctionDef::node(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.node) + return node_.Get(index); +} +inline ::tensorflow::FunctionDef_Node* FunctionDef::mutable_node(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.node) + return node_.Mutable(index); +} +inline ::tensorflow::FunctionDef_Node* FunctionDef::add_node() { + // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.node) + return node_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef_Node >* +FunctionDef::mutable_node() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.node) + return &node_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::FunctionDef_Node >& +FunctionDef::node() const { + // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.node) + return node_; +} + +inline const FunctionDef* FunctionDef::internal_default_instance() { + return &FunctionDef_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// GradientDef + +// optional string function_name = 1; +inline void GradientDef::clear_function_name() { + function_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& GradientDef::function_name() const { + // @@protoc_insertion_point(field_get:tensorflow.GradientDef.function_name) + return function_name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void GradientDef::set_function_name(const ::std::string& value) { + + function_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.GradientDef.function_name) +} +inline void GradientDef::set_function_name(const char* value) { + + function_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.GradientDef.function_name) +} +inline void GradientDef::set_function_name(const char* value, + size_t size) { + + function_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.GradientDef.function_name) +} +inline ::std::string* GradientDef::mutable_function_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.GradientDef.function_name) + return function_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* GradientDef::release_function_name() { + // @@protoc_insertion_point(field_release:tensorflow.GradientDef.function_name) + + return function_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* GradientDef::unsafe_arena_release_function_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GradientDef.function_name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return function_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void GradientDef::set_allocated_function_name(::std::string* function_name) { + if (function_name != NULL) { + + } else { + + } + function_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), function_name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.GradientDef.function_name) +} +inline void GradientDef::unsafe_arena_set_allocated_function_name( + ::std::string* function_name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (function_name != NULL) { + + } else { + + } + function_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + function_name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GradientDef.function_name) +} + +// optional string gradient_func = 2; +inline void GradientDef::clear_gradient_func() { + gradient_func_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& GradientDef::gradient_func() const { + // @@protoc_insertion_point(field_get:tensorflow.GradientDef.gradient_func) + return gradient_func_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void GradientDef::set_gradient_func(const ::std::string& value) { + + gradient_func_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.GradientDef.gradient_func) +} +inline void GradientDef::set_gradient_func(const char* value) { + + gradient_func_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.GradientDef.gradient_func) +} +inline void GradientDef::set_gradient_func(const char* value, + size_t size) { + + gradient_func_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.GradientDef.gradient_func) +} +inline ::std::string* GradientDef::mutable_gradient_func() { + + // @@protoc_insertion_point(field_mutable:tensorflow.GradientDef.gradient_func) + return gradient_func_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* GradientDef::release_gradient_func() { + // @@protoc_insertion_point(field_release:tensorflow.GradientDef.gradient_func) + + return gradient_func_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* GradientDef::unsafe_arena_release_gradient_func() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GradientDef.gradient_func) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return gradient_func_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void GradientDef::set_allocated_gradient_func(::std::string* gradient_func) { + if (gradient_func != NULL) { + + } else { + + } + gradient_func_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), gradient_func, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.GradientDef.gradient_func) +} +inline void GradientDef::unsafe_arena_set_allocated_gradient_func( + ::std::string* gradient_func) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (gradient_func != NULL) { + + } else { + + } + gradient_func_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + gradient_func, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GradientDef.gradient_func) +} + +inline const GradientDef* GradientDef::internal_default_instance() { + return &GradientDef_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_function_2eproto__INCLUDED diff --git a/modules/dnn/misc/tensorflow/graph.pb.cc b/modules/dnn/misc/tensorflow/graph.pb.cc new file mode 100644 index 0000000000..21cec2e77e --- /dev/null +++ b/modules/dnn/misc/tensorflow/graph.pb.cc @@ -0,0 +1,1687 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: graph.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "graph.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::Descriptor* GraphDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GraphDef_reflection_ = NULL; +const ::google::protobuf::Descriptor* NodeDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NodeDef_reflection_ = NULL; +const ::google::protobuf::Descriptor* NodeDef_AttrEntry_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_graph_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_graph_2eproto() { + protobuf_AddDesc_graph_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "graph.proto"); + GOOGLE_CHECK(file != NULL); + GraphDef_descriptor_ = file->message_type(0); + static const int GraphDef_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GraphDef, node_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GraphDef, versions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GraphDef, version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GraphDef, library_), + }; + GraphDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + GraphDef_descriptor_, + GraphDef::internal_default_instance(), + GraphDef_offsets_, + -1, + -1, + -1, + sizeof(GraphDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GraphDef, _internal_metadata_)); + NodeDef_descriptor_ = file->message_type(1); + static const int NodeDef_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeDef, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeDef, op_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeDef, input_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeDef, device_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeDef, attr_), + }; + NodeDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + NodeDef_descriptor_, + NodeDef::internal_default_instance(), + NodeDef_offsets_, + -1, + -1, + -1, + sizeof(NodeDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeDef, _internal_metadata_)); + NodeDef_AttrEntry_descriptor_ = NodeDef_descriptor_->nested_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_graph_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GraphDef_descriptor_, GraphDef::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NodeDef_descriptor_, NodeDef::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NodeDef_AttrEntry_descriptor_, + ::google::protobuf::internal::MapEntry< + ::std::string, + ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0>::CreateDefaultInstance( + NodeDef_AttrEntry_descriptor_)); +} + +} // namespace + +void protobuf_ShutdownFile_graph_2eproto() { + GraphDef_default_instance_.Shutdown(); + delete GraphDef_reflection_; + NodeDef_default_instance_.Shutdown(); + delete NodeDef_reflection_; +} + +void protobuf_InitDefaults_graph_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::tensorflow::protobuf_InitDefaults_attr_5fvalue_2eproto(); + ::tensorflow::protobuf_InitDefaults_function_2eproto(); + ::tensorflow::protobuf_InitDefaults_versions_2eproto(); + GraphDef_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + NodeDef_default_instance_.DefaultConstruct(); + GraphDef_default_instance_.get_mutable()->InitAsDefaultInstance(); + NodeDef_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_graph_2eproto_once_); +void protobuf_InitDefaults_graph_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_graph_2eproto_once_, + &protobuf_InitDefaults_graph_2eproto_impl); +} +void protobuf_AddDesc_graph_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_graph_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\013graph.proto\022\ntensorflow\032\020attr_value.pr" + "oto\032\016function.proto\032\016versions.proto\"\235\001\n\010" + "GraphDef\022!\n\004node\030\001 \003(\0132\023.tensorflow.Node" + "Def\022(\n\010versions\030\004 \001(\0132\026.tensorflow.Versi" + "onDef\022\023\n\007version\030\003 \001(\005B\002\030\001\022/\n\007library\030\002 " + "\001(\0132\036.tensorflow.FunctionDefLibrary\"\263\001\n\007" + "NodeDef\022\014\n\004name\030\001 \001(\t\022\n\n\002op\030\002 \001(\t\022\r\n\005inp" + "ut\030\003 \003(\t\022\016\n\006device\030\004 \001(\t\022+\n\004attr\030\005 \003(\0132\035" + ".tensorflow.NodeDef.AttrEntry\032B\n\tAttrEnt" + "ry\022\013\n\003key\030\001 \001(\t\022$\n\005value\030\002 \001(\0132\025.tensorf" + "low.AttrValue:\0028\001B,\n\030org.tensorflow.fram" + "eworkB\013GraphProtosP\001\370\001\001b\006proto3", 471); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "graph.proto", &protobuf_RegisterTypes); + ::tensorflow::protobuf_AddDesc_attr_5fvalue_2eproto(); + ::tensorflow::protobuf_AddDesc_function_2eproto(); + ::tensorflow::protobuf_AddDesc_versions_2eproto(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_graph_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_graph_2eproto_once_); +void protobuf_AddDesc_graph_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_graph_2eproto_once_, + &protobuf_AddDesc_graph_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_graph_2eproto { + StaticDescriptorInitializer_graph_2eproto() { + protobuf_AddDesc_graph_2eproto(); + } +} static_descriptor_initializer_graph_2eproto_; + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +void GraphDef::_slow_mutable_versions() { + versions_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::VersionDef >( + GetArenaNoVirtual()); +} +::tensorflow::VersionDef* GraphDef::_slow_release_versions() { + if (versions_ == NULL) { + return NULL; + } else { + ::tensorflow::VersionDef* temp = new ::tensorflow::VersionDef(*versions_); + versions_ = NULL; + return temp; + } +} +::tensorflow::VersionDef* GraphDef::unsafe_arena_release_versions() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphDef.versions) + + ::tensorflow::VersionDef* temp = versions_; + versions_ = NULL; + return temp; +} +void GraphDef::_slow_set_allocated_versions( + ::google::protobuf::Arena* message_arena, ::tensorflow::VersionDef** versions) { + if (message_arena != NULL && + ::google::protobuf::Arena::GetArena(*versions) == NULL) { + message_arena->Own(*versions); + } else if (message_arena != + ::google::protobuf::Arena::GetArena(*versions)) { + ::tensorflow::VersionDef* new_versions = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::VersionDef >( + message_arena); + new_versions->CopyFrom(**versions); + *versions = new_versions; + } +} +void GraphDef::unsafe_arena_set_allocated_versions( + ::tensorflow::VersionDef* versions) { + if (GetArenaNoVirtual() == NULL) { + delete versions_; + } + versions_ = versions; + if (versions) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphDef.versions) +} +void GraphDef::_slow_mutable_library() { + library_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::FunctionDefLibrary >( + GetArenaNoVirtual()); +} +::tensorflow::FunctionDefLibrary* GraphDef::_slow_release_library() { + if (library_ == NULL) { + return NULL; + } else { + ::tensorflow::FunctionDefLibrary* temp = new ::tensorflow::FunctionDefLibrary(*library_); + library_ = NULL; + return temp; + } +} +::tensorflow::FunctionDefLibrary* GraphDef::unsafe_arena_release_library() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphDef.library) + + ::tensorflow::FunctionDefLibrary* temp = library_; + library_ = NULL; + return temp; +} +void GraphDef::_slow_set_allocated_library( + ::google::protobuf::Arena* message_arena, ::tensorflow::FunctionDefLibrary** library) { + if (message_arena != NULL && + ::google::protobuf::Arena::GetArena(*library) == NULL) { + message_arena->Own(*library); + } else if (message_arena != + ::google::protobuf::Arena::GetArena(*library)) { + ::tensorflow::FunctionDefLibrary* new_library = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::FunctionDefLibrary >( + message_arena); + new_library->CopyFrom(**library); + *library = new_library; + } +} +void GraphDef::unsafe_arena_set_allocated_library( + ::tensorflow::FunctionDefLibrary* library) { + if (GetArenaNoVirtual() == NULL) { + delete library_; + } + library_ = library; + if (library) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphDef.library) +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int GraphDef::kNodeFieldNumber; +const int GraphDef::kVersionsFieldNumber; +const int GraphDef::kVersionFieldNumber; +const int GraphDef::kLibraryFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +GraphDef::GraphDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_graph_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.GraphDef) +} +GraphDef::GraphDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + node_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_graph_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.GraphDef) +} + +void GraphDef::InitAsDefaultInstance() { + versions_ = const_cast< ::tensorflow::VersionDef*>( + ::tensorflow::VersionDef::internal_default_instance()); + library_ = const_cast< ::tensorflow::FunctionDefLibrary*>( + ::tensorflow::FunctionDefLibrary::internal_default_instance()); +} + +GraphDef::GraphDef(const GraphDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.GraphDef) +} + +void GraphDef::SharedCtor() { + versions_ = NULL; + library_ = NULL; + version_ = 0; + _cached_size_ = 0; +} + +GraphDef::~GraphDef() { + // @@protoc_insertion_point(destructor:tensorflow.GraphDef) + SharedDtor(); +} + +void GraphDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + if (this != &GraphDef_default_instance_.get()) { + delete versions_; + delete library_; + } +} + +void GraphDef::ArenaDtor(void* object) { + GraphDef* _this = reinterpret_cast< GraphDef* >(object); + (void)_this; +} +void GraphDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void GraphDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GraphDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GraphDef_descriptor_; +} + +const GraphDef& GraphDef::default_instance() { + protobuf_InitDefaults_graph_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed GraphDef_default_instance_; + +GraphDef* GraphDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void GraphDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.GraphDef) + if (GetArenaNoVirtual() == NULL && versions_ != NULL) delete versions_; + versions_ = NULL; + version_ = 0; + if (GetArenaNoVirtual() == NULL && library_ != NULL) delete library_; + library_ = NULL; + node_.Clear(); +} + +bool GraphDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.GraphDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .tensorflow.NodeDef node = 1; + case 1: { + if (tag == 10) { + DO_(input->IncrementRecursionDepth()); + parse_loop_node: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_node())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_loop_node; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(18)) goto parse_library; + break; + } + + // optional .tensorflow.FunctionDefLibrary library = 2; + case 2: { + if (tag == 18) { + parse_library: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_library())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_version; + break; + } + + // optional int32 version = 3 [deprecated = true]; + case 3: { + if (tag == 24) { + parse_version: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &version_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_versions; + break; + } + + // optional .tensorflow.VersionDef versions = 4; + case 4: { + if (tag == 34) { + parse_versions: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_versions())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.GraphDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.GraphDef) + return false; +#undef DO_ +} + +void GraphDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.GraphDef) + // repeated .tensorflow.NodeDef node = 1; + for (unsigned int i = 0, n = this->node_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->node(i), output); + } + + // optional .tensorflow.FunctionDefLibrary library = 2; + if (this->has_library()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *this->library_, output); + } + + // optional int32 version = 3 [deprecated = true]; + if (this->version() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->version(), output); + } + + // optional .tensorflow.VersionDef versions = 4; + if (this->has_versions()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, *this->versions_, output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.GraphDef) +} + +::google::protobuf::uint8* GraphDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphDef) + // repeated .tensorflow.NodeDef node = 1; + for (unsigned int i = 0, n = this->node_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, this->node(i), false, target); + } + + // optional .tensorflow.FunctionDefLibrary library = 2; + if (this->has_library()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, *this->library_, false, target); + } + + // optional int32 version = 3 [deprecated = true]; + if (this->version() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->version(), target); + } + + // optional .tensorflow.VersionDef versions = 4; + if (this->has_versions()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 4, *this->versions_, false, target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphDef) + return target; +} + +size_t GraphDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphDef) + size_t total_size = 0; + + // optional .tensorflow.VersionDef versions = 4; + if (this->has_versions()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->versions_); + } + + // optional int32 version = 3 [deprecated = true]; + if (this->version() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->version()); + } + + // optional .tensorflow.FunctionDefLibrary library = 2; + if (this->has_library()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->library_); + } + + // repeated .tensorflow.NodeDef node = 1; + { + unsigned int count = this->node_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->node(i)); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GraphDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.GraphDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const GraphDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.GraphDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.GraphDef) + UnsafeMergeFrom(*source); + } +} + +void GraphDef::MergeFrom(const GraphDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void GraphDef::UnsafeMergeFrom(const GraphDef& from) { + GOOGLE_DCHECK(&from != this); + node_.MergeFrom(from.node_); + if (from.has_versions()) { + mutable_versions()->::tensorflow::VersionDef::MergeFrom(from.versions()); + } + if (from.version() != 0) { + set_version(from.version()); + } + if (from.has_library()) { + mutable_library()->::tensorflow::FunctionDefLibrary::MergeFrom(from.library()); + } +} + +void GraphDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.GraphDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GraphDef::CopyFrom(const GraphDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool GraphDef::IsInitialized() const { + + return true; +} + +void GraphDef::Swap(GraphDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + GraphDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void GraphDef::UnsafeArenaSwap(GraphDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void GraphDef::InternalSwap(GraphDef* other) { + node_.UnsafeArenaSwap(&other->node_); + std::swap(versions_, other->versions_); + std::swap(version_, other->version_); + std::swap(library_, other->library_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata GraphDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GraphDef_descriptor_; + metadata.reflection = GraphDef_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// GraphDef + +// repeated .tensorflow.NodeDef node = 1; +int GraphDef::node_size() const { + return node_.size(); +} +void GraphDef::clear_node() { + node_.Clear(); +} +const ::tensorflow::NodeDef& GraphDef::node(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.node) + return node_.Get(index); +} +::tensorflow::NodeDef* GraphDef::mutable_node(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.node) + return node_.Mutable(index); +} +::tensorflow::NodeDef* GraphDef::add_node() { + // @@protoc_insertion_point(field_add:tensorflow.GraphDef.node) + return node_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::NodeDef >* +GraphDef::mutable_node() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphDef.node) + return &node_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeDef >& +GraphDef::node() const { + // @@protoc_insertion_point(field_list:tensorflow.GraphDef.node) + return node_; +} + +// optional .tensorflow.VersionDef versions = 4; +bool GraphDef::has_versions() const { + return this != internal_default_instance() && versions_ != NULL; +} +void GraphDef::clear_versions() { + if (GetArenaNoVirtual() == NULL && versions_ != NULL) delete versions_; + versions_ = NULL; +} +const ::tensorflow::VersionDef& GraphDef::versions() const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.versions) + return versions_ != NULL ? *versions_ + : *::tensorflow::VersionDef::internal_default_instance(); +} +::tensorflow::VersionDef* GraphDef::mutable_versions() { + + if (versions_ == NULL) { + _slow_mutable_versions(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.versions) + return versions_; +} +::tensorflow::VersionDef* GraphDef::release_versions() { + // @@protoc_insertion_point(field_release:tensorflow.GraphDef.versions) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_versions(); + } else { + ::tensorflow::VersionDef* temp = versions_; + versions_ = NULL; + return temp; + } +} + void GraphDef::set_allocated_versions(::tensorflow::VersionDef* versions) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete versions_; + } + if (versions != NULL) { + _slow_set_allocated_versions(message_arena, &versions); + } + versions_ = versions; + if (versions) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDef.versions) +} + +// optional int32 version = 3 [deprecated = true]; +void GraphDef::clear_version() { + version_ = 0; +} +::google::protobuf::int32 GraphDef::version() const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.version) + return version_; +} +void GraphDef::set_version(::google::protobuf::int32 value) { + + version_ = value; + // @@protoc_insertion_point(field_set:tensorflow.GraphDef.version) +} + +// optional .tensorflow.FunctionDefLibrary library = 2; +bool GraphDef::has_library() const { + return this != internal_default_instance() && library_ != NULL; +} +void GraphDef::clear_library() { + if (GetArenaNoVirtual() == NULL && library_ != NULL) delete library_; + library_ = NULL; +} +const ::tensorflow::FunctionDefLibrary& GraphDef::library() const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.library) + return library_ != NULL ? *library_ + : *::tensorflow::FunctionDefLibrary::internal_default_instance(); +} +::tensorflow::FunctionDefLibrary* GraphDef::mutable_library() { + + if (library_ == NULL) { + _slow_mutable_library(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.library) + return library_; +} +::tensorflow::FunctionDefLibrary* GraphDef::release_library() { + // @@protoc_insertion_point(field_release:tensorflow.GraphDef.library) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_library(); + } else { + ::tensorflow::FunctionDefLibrary* temp = library_; + library_ = NULL; + return temp; + } +} + void GraphDef::set_allocated_library(::tensorflow::FunctionDefLibrary* library) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete library_; + } + if (library != NULL) { + _slow_set_allocated_library(message_arena, &library); + } + library_ = library; + if (library) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDef.library) +} + +inline const GraphDef* GraphDef::internal_default_instance() { + return &GraphDef_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NodeDef::kNameFieldNumber; +const int NodeDef::kOpFieldNumber; +const int NodeDef::kInputFieldNumber; +const int NodeDef::kDeviceFieldNumber; +const int NodeDef::kAttrFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NodeDef::NodeDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_graph_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.NodeDef) +} +NodeDef::NodeDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + input_(arena), + attr_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_graph_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.NodeDef) +} + +void NodeDef::InitAsDefaultInstance() { +} + +NodeDef::NodeDef(const NodeDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.NodeDef) +} + +void NodeDef::SharedCtor() { + attr_.SetAssignDescriptorCallback( + protobuf_AssignDescriptorsOnce); + attr_.SetEntryDescriptor( + &::tensorflow::NodeDef_AttrEntry_descriptor_); + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + op_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + device_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + _cached_size_ = 0; +} + +NodeDef::~NodeDef() { + // @@protoc_insertion_point(destructor:tensorflow.NodeDef) + SharedDtor(); +} + +void NodeDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + name_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + op_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + device_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); +} + +void NodeDef::ArenaDtor(void* object) { + NodeDef* _this = reinterpret_cast< NodeDef* >(object); + (void)_this; +} +void NodeDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void NodeDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NodeDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NodeDef_descriptor_; +} + +const NodeDef& NodeDef::default_instance() { + protobuf_InitDefaults_graph_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed NodeDef_default_instance_; + +NodeDef* NodeDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void NodeDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.NodeDef) + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + op_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + device_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + input_.Clear(); + attr_.Clear(); +} + +bool NodeDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.NodeDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.NodeDef.name")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_op; + break; + } + + // optional string op = 2; + case 2: { + if (tag == 18) { + parse_op: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_op())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->op().data(), this->op().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.NodeDef.op")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_input; + break; + } + + // repeated string input = 3; + case 3: { + if (tag == 26) { + parse_input: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_input())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->input(this->input_size() - 1).data(), + this->input(this->input_size() - 1).length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.NodeDef.input")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_input; + if (input->ExpectTag(34)) goto parse_device; + break; + } + + // optional string device = 4; + case 4: { + if (tag == 34) { + parse_device: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_device())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->device().data(), this->device().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.NodeDef.device")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_attr; + break; + } + + // map attr = 5; + case 5: { + if (tag == 42) { + parse_attr: + DO_(input->IncrementRecursionDepth()); + parse_loop_attr: + NodeDef_AttrEntry::Parser< ::google::protobuf::internal::MapField< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 >, + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue > > parser(&attr_); + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, &parser)); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + parser.key().data(), parser.key().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.NodeDef.AttrEntry.key")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_loop_attr; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.NodeDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.NodeDef) + return false; +#undef DO_ +} + +void NodeDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.NodeDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional string op = 2; + if (this->op().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->op().data(), this->op().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.op"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->op(), output); + } + + // repeated string input = 3; + for (int i = 0; i < this->input_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->input(i).data(), this->input(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.input"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->input(i), output); + } + + // optional string device = 4; + if (this->device().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->device().data(), this->device().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.device"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->device(), output); + } + + // map attr = 5; + if (!this->attr().empty()) { + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::google::protobuf::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), p->first.length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.AttrEntry.key"); + } + }; + + if (output->IsSerializationDeterminstic() && + this->attr().size() > 1) { + ::google::protobuf::scoped_array items( + new SortItem[this->attr().size()]); + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::size_type size_type; + size_type n = 0; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it, ++n) { + items[n] = SortItem(&*it); + } + ::std::sort(&items[0], &items[n], Less()); + ::google::protobuf::scoped_ptr entry; + for (size_type i = 0; i < n; i++) { + entry.reset(attr_.NewEntryWrapper( + items[i]->first, items[i]->second)); + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *entry, output); + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(items[i]); + } + } else { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + entry.reset(attr_.NewEntryWrapper( + it->first, it->second)); + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *entry, output); + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(&*it); + } + } + } + + // @@protoc_insertion_point(serialize_end:tensorflow.NodeDef) +} + +::google::protobuf::uint8* NodeDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.NodeDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional string op = 2; + if (this->op().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->op().data(), this->op().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.op"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->op(), target); + } + + // repeated string input = 3; + for (int i = 0; i < this->input_size(); i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->input(i).data(), this->input(i).length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.input"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->input(i), target); + } + + // optional string device = 4; + if (this->device().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->device().data(), this->device().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.device"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->device(), target); + } + + // map attr = 5; + if (!this->attr().empty()) { + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::google::protobuf::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), p->first.length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.NodeDef.AttrEntry.key"); + } + }; + + if (deterministic && + this->attr().size() > 1) { + ::google::protobuf::scoped_array items( + new SortItem[this->attr().size()]); + typedef ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::size_type size_type; + size_type n = 0; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it, ++n) { + items[n] = SortItem(&*it); + } + ::std::sort(&items[0], &items[n], Less()); + ::google::protobuf::scoped_ptr entry; + for (size_type i = 0; i < n; i++) { + entry.reset(attr_.NewEntryWrapper( + items[i]->first, items[i]->second)); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *entry, deterministic, target); +; + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(items[i]); + } + } else { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + entry.reset(attr_.NewEntryWrapper( + it->first, it->second)); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 5, *entry, deterministic, target); +; + if (entry->GetArena() != NULL) { + entry.release(); + } + Utf8Check::Check(&*it); + } + } + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.NodeDef) + return target; +} + +size_t NodeDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.NodeDef) + size_t total_size = 0; + + // optional string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string op = 2; + if (this->op().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->op()); + } + + // optional string device = 4; + if (this->device().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->device()); + } + + // repeated string input = 3; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->input_size()); + for (int i = 0; i < this->input_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->input(i)); + } + + // map attr = 5; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->attr_size()); + { + ::google::protobuf::scoped_ptr entry; + for (::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >::const_iterator + it = this->attr().begin(); + it != this->attr().end(); ++it) { + if (entry.get() != NULL && entry->GetArena() != NULL) { + entry.release(); + } + entry.reset(attr_.NewEntryWrapper(it->first, it->second)); + total_size += ::google::protobuf::internal::WireFormatLite:: + MessageSizeNoVirtual(*entry); + } + if (entry.get() != NULL && entry->GetArena() != NULL) { + entry.release(); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NodeDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.NodeDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const NodeDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.NodeDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.NodeDef) + UnsafeMergeFrom(*source); + } +} + +void NodeDef::MergeFrom(const NodeDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.NodeDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void NodeDef::UnsafeMergeFrom(const NodeDef& from) { + GOOGLE_DCHECK(&from != this); + input_.UnsafeMergeFrom(from.input_); + attr_.MergeFrom(from.attr_); + if (from.name().size() > 0) { + set_name(from.name()); + } + if (from.op().size() > 0) { + set_op(from.op()); + } + if (from.device().size() > 0) { + set_device(from.device()); + } +} + +void NodeDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.NodeDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NodeDef::CopyFrom(const NodeDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.NodeDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool NodeDef::IsInitialized() const { + + return true; +} + +void NodeDef::Swap(NodeDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + NodeDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void NodeDef::UnsafeArenaSwap(NodeDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void NodeDef::InternalSwap(NodeDef* other) { + name_.Swap(&other->name_); + op_.Swap(&other->op_); + input_.UnsafeArenaSwap(&other->input_); + device_.Swap(&other->device_); + attr_.Swap(&other->attr_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NodeDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NodeDef_descriptor_; + metadata.reflection = NodeDef_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// NodeDef + +// optional string name = 1; +void NodeDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& NodeDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void NodeDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.name) +} +void NodeDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.name) +} +void NodeDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.name) +} +::std::string* NodeDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NodeDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.NodeDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NodeDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void NodeDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.name) +} +void NodeDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.name) +} + +// optional string op = 2; +void NodeDef::clear_op() { + op_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& NodeDef::op() const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.op) + return op_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void NodeDef::set_op(const ::std::string& value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.op) +} +void NodeDef::set_op(const char* value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.op) +} +void NodeDef::set_op(const char* value, + size_t size) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.op) +} +::std::string* NodeDef::mutable_op() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.op) + return op_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NodeDef::release_op() { + // @@protoc_insertion_point(field_release:tensorflow.NodeDef.op) + + return op_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NodeDef::unsafe_arena_release_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeDef.op) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return op_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void NodeDef::set_allocated_op(::std::string* op) { + if (op != NULL) { + + } else { + + } + op_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), op, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.op) +} +void NodeDef::unsafe_arena_set_allocated_op( + ::std::string* op) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (op != NULL) { + + } else { + + } + op_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + op, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.op) +} + +// repeated string input = 3; +int NodeDef::input_size() const { + return input_.size(); +} +void NodeDef::clear_input() { + input_.Clear(); +} +const ::std::string& NodeDef::input(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.input) + return input_.Get(index); +} +::std::string* NodeDef::mutable_input(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.input) + return input_.Mutable(index); +} +void NodeDef::set_input(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.input) + input_.Mutable(index)->assign(value); +} +void NodeDef::set_input(int index, const char* value) { + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.input) +} +void NodeDef::set_input(int index, const char* value, size_t size) { + input_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.input) +} +::std::string* NodeDef::add_input() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.NodeDef.input) + return input_.Add(); +} +void NodeDef::add_input(const ::std::string& value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.NodeDef.input) +} +void NodeDef::add_input(const char* value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.NodeDef.input) +} +void NodeDef::add_input(const char* value, size_t size) { + input_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.NodeDef.input) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +NodeDef::input() const { + // @@protoc_insertion_point(field_list:tensorflow.NodeDef.input) + return input_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +NodeDef::mutable_input() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeDef.input) + return &input_; +} + +// optional string device = 4; +void NodeDef::clear_device() { + device_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& NodeDef::device() const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.device) + return device_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void NodeDef::set_device(const ::std::string& value) { + + device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.device) +} +void NodeDef::set_device(const char* value) { + + device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.device) +} +void NodeDef::set_device(const char* value, + size_t size) { + + device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.device) +} +::std::string* NodeDef::mutable_device() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.device) + return device_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NodeDef::release_device() { + // @@protoc_insertion_point(field_release:tensorflow.NodeDef.device) + + return device_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* NodeDef::unsafe_arena_release_device() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeDef.device) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return device_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void NodeDef::set_allocated_device(::std::string* device) { + if (device != NULL) { + + } else { + + } + device_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), device, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.device) +} +void NodeDef::unsafe_arena_set_allocated_device( + ::std::string* device) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (device != NULL) { + + } else { + + } + device_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + device, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.device) +} + +// map attr = 5; +int NodeDef::attr_size() const { + return attr_.size(); +} +void NodeDef::clear_attr() { + attr_.Clear(); +} + const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& +NodeDef::attr() const { + // @@protoc_insertion_point(field_map:tensorflow.NodeDef.attr) + return attr_.GetMap(); +} + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* +NodeDef::mutable_attr() { + // @@protoc_insertion_point(field_mutable_map:tensorflow.NodeDef.attr) + return attr_.MutableMap(); +} + +inline const NodeDef* NodeDef::internal_default_instance() { + return &NodeDef_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/graph.pb.h b/modules/dnn/misc/tensorflow/graph.pb.h new file mode 100644 index 0000000000..f4d54bc7f9 --- /dev/null +++ b/modules/dnn/misc/tensorflow/graph.pb.h @@ -0,0 +1,814 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: graph.proto + +#ifndef PROTOBUF_graph_2eproto__INCLUDED +#define PROTOBUF_graph_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "attr_value.pb.h" +#include "function.pb.h" +#include "versions.pb.h" +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_graph_2eproto(); +void protobuf_InitDefaults_graph_2eproto(); +void protobuf_AssignDesc_graph_2eproto(); +void protobuf_ShutdownFile_graph_2eproto(); + +class GraphDef; +class NodeDef; + +// =================================================================== + +class GraphDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphDef) */ { + public: + GraphDef(); + virtual ~GraphDef(); + + GraphDef(const GraphDef& from); + + inline GraphDef& operator=(const GraphDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const GraphDef& default_instance(); + + static const GraphDef* internal_default_instance(); + + void UnsafeArenaSwap(GraphDef* other); + void Swap(GraphDef* other); + + // implements Message ---------------------------------------------- + + inline GraphDef* New() const { return New(NULL); } + + GraphDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GraphDef& from); + void MergeFrom(const GraphDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(GraphDef* other); + void UnsafeMergeFrom(const GraphDef& from); + protected: + explicit GraphDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .tensorflow.NodeDef node = 1; + int node_size() const; + void clear_node(); + static const int kNodeFieldNumber = 1; + const ::tensorflow::NodeDef& node(int index) const; + ::tensorflow::NodeDef* mutable_node(int index); + ::tensorflow::NodeDef* add_node(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeDef >* + mutable_node(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeDef >& + node() const; + + // optional .tensorflow.VersionDef versions = 4; + bool has_versions() const; + void clear_versions(); + static const int kVersionsFieldNumber = 4; + private: + void _slow_mutable_versions(); + void _slow_set_allocated_versions( + ::google::protobuf::Arena* message_arena, ::tensorflow::VersionDef** versions); + ::tensorflow::VersionDef* _slow_release_versions(); + public: + const ::tensorflow::VersionDef& versions() const; + ::tensorflow::VersionDef* mutable_versions(); + ::tensorflow::VersionDef* release_versions(); + void set_allocated_versions(::tensorflow::VersionDef* versions); + ::tensorflow::VersionDef* unsafe_arena_release_versions(); + void unsafe_arena_set_allocated_versions( + ::tensorflow::VersionDef* versions); + + // optional int32 version = 3 [deprecated = true]; + GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_version(); + GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kVersionFieldNumber = 3; + GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::int32 version() const; + GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_version(::google::protobuf::int32 value); + + // optional .tensorflow.FunctionDefLibrary library = 2; + bool has_library() const; + void clear_library(); + static const int kLibraryFieldNumber = 2; + private: + void _slow_mutable_library(); + void _slow_set_allocated_library( + ::google::protobuf::Arena* message_arena, ::tensorflow::FunctionDefLibrary** library); + ::tensorflow::FunctionDefLibrary* _slow_release_library(); + public: + const ::tensorflow::FunctionDefLibrary& library() const; + ::tensorflow::FunctionDefLibrary* mutable_library(); + ::tensorflow::FunctionDefLibrary* release_library(); + void set_allocated_library(::tensorflow::FunctionDefLibrary* library); + ::tensorflow::FunctionDefLibrary* unsafe_arena_release_library(); + void unsafe_arena_set_allocated_library( + ::tensorflow::FunctionDefLibrary* library); + + // @@protoc_insertion_point(class_scope:tensorflow.GraphDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeDef > node_; + ::tensorflow::VersionDef* versions_; + ::tensorflow::FunctionDefLibrary* library_; + ::google::protobuf::int32 version_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_graph_2eproto_impl(); + friend void protobuf_AddDesc_graph_2eproto_impl(); + friend void protobuf_AssignDesc_graph_2eproto(); + friend void protobuf_ShutdownFile_graph_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed GraphDef_default_instance_; + +// ------------------------------------------------------------------- + +class NodeDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.NodeDef) */ { + public: + NodeDef(); + virtual ~NodeDef(); + + NodeDef(const NodeDef& from); + + inline NodeDef& operator=(const NodeDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const NodeDef& default_instance(); + + static const NodeDef* internal_default_instance(); + + void UnsafeArenaSwap(NodeDef* other); + void Swap(NodeDef* other); + + // implements Message ---------------------------------------------- + + inline NodeDef* New() const { return New(NULL); } + + NodeDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NodeDef& from); + void MergeFrom(const NodeDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NodeDef* other); + void UnsafeMergeFrom(const NodeDef& from); + protected: + explicit NodeDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + + // accessors ------------------------------------------------------- + + // optional string name = 1; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + ::std::string* unsafe_arena_release_name(); + void unsafe_arena_set_allocated_name( + ::std::string* name); + + // optional string op = 2; + void clear_op(); + static const int kOpFieldNumber = 2; + const ::std::string& op() const; + void set_op(const ::std::string& value); + void set_op(const char* value); + void set_op(const char* value, size_t size); + ::std::string* mutable_op(); + ::std::string* release_op(); + void set_allocated_op(::std::string* op); + ::std::string* unsafe_arena_release_op(); + void unsafe_arena_set_allocated_op( + ::std::string* op); + + // repeated string input = 3; + int input_size() const; + void clear_input(); + static const int kInputFieldNumber = 3; + const ::std::string& input(int index) const; + ::std::string* mutable_input(int index); + void set_input(int index, const ::std::string& value); + void set_input(int index, const char* value); + void set_input(int index, const char* value, size_t size); + ::std::string* add_input(); + void add_input(const ::std::string& value); + void add_input(const char* value); + void add_input(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input(); + + // optional string device = 4; + void clear_device(); + static const int kDeviceFieldNumber = 4; + const ::std::string& device() const; + void set_device(const ::std::string& value); + void set_device(const char* value); + void set_device(const char* value, size_t size); + ::std::string* mutable_device(); + ::std::string* release_device(); + void set_allocated_device(::std::string* device); + ::std::string* unsafe_arena_release_device(); + void unsafe_arena_set_allocated_device( + ::std::string* device); + + // map attr = 5; + int attr_size() const; + void clear_attr(); + static const int kAttrFieldNumber = 5; + const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& + attr() const; + ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* + mutable_attr(); + + // @@protoc_insertion_point(class_scope:tensorflow.NodeDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::std::string> input_; + typedef ::google::protobuf::internal::MapEntryLite< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 > + NodeDef_AttrEntry; + ::google::protobuf::internal::MapField< + ::std::string, ::tensorflow::AttrValue, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, + 0 > attr_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr op_; + ::google::protobuf::internal::ArenaStringPtr device_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_graph_2eproto_impl(); + friend void protobuf_AddDesc_graph_2eproto_impl(); + friend void protobuf_AssignDesc_graph_2eproto(); + friend void protobuf_ShutdownFile_graph_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed NodeDef_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// GraphDef + +// repeated .tensorflow.NodeDef node = 1; +inline int GraphDef::node_size() const { + return node_.size(); +} +inline void GraphDef::clear_node() { + node_.Clear(); +} +inline const ::tensorflow::NodeDef& GraphDef::node(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.node) + return node_.Get(index); +} +inline ::tensorflow::NodeDef* GraphDef::mutable_node(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.node) + return node_.Mutable(index); +} +inline ::tensorflow::NodeDef* GraphDef::add_node() { + // @@protoc_insertion_point(field_add:tensorflow.GraphDef.node) + return node_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeDef >* +GraphDef::mutable_node() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphDef.node) + return &node_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeDef >& +GraphDef::node() const { + // @@protoc_insertion_point(field_list:tensorflow.GraphDef.node) + return node_; +} + +// optional .tensorflow.VersionDef versions = 4; +inline bool GraphDef::has_versions() const { + return this != internal_default_instance() && versions_ != NULL; +} +inline void GraphDef::clear_versions() { + if (GetArenaNoVirtual() == NULL && versions_ != NULL) delete versions_; + versions_ = NULL; +} +inline const ::tensorflow::VersionDef& GraphDef::versions() const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.versions) + return versions_ != NULL ? *versions_ + : *::tensorflow::VersionDef::internal_default_instance(); +} +inline ::tensorflow::VersionDef* GraphDef::mutable_versions() { + + if (versions_ == NULL) { + _slow_mutable_versions(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.versions) + return versions_; +} +inline ::tensorflow::VersionDef* GraphDef::release_versions() { + // @@protoc_insertion_point(field_release:tensorflow.GraphDef.versions) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_versions(); + } else { + ::tensorflow::VersionDef* temp = versions_; + versions_ = NULL; + return temp; + } +} +inline void GraphDef::set_allocated_versions(::tensorflow::VersionDef* versions) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete versions_; + } + if (versions != NULL) { + _slow_set_allocated_versions(message_arena, &versions); + } + versions_ = versions; + if (versions) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDef.versions) +} + +// optional int32 version = 3 [deprecated = true]; +inline void GraphDef::clear_version() { + version_ = 0; +} +inline ::google::protobuf::int32 GraphDef::version() const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.version) + return version_; +} +inline void GraphDef::set_version(::google::protobuf::int32 value) { + + version_ = value; + // @@protoc_insertion_point(field_set:tensorflow.GraphDef.version) +} + +// optional .tensorflow.FunctionDefLibrary library = 2; +inline bool GraphDef::has_library() const { + return this != internal_default_instance() && library_ != NULL; +} +inline void GraphDef::clear_library() { + if (GetArenaNoVirtual() == NULL && library_ != NULL) delete library_; + library_ = NULL; +} +inline const ::tensorflow::FunctionDefLibrary& GraphDef::library() const { + // @@protoc_insertion_point(field_get:tensorflow.GraphDef.library) + return library_ != NULL ? *library_ + : *::tensorflow::FunctionDefLibrary::internal_default_instance(); +} +inline ::tensorflow::FunctionDefLibrary* GraphDef::mutable_library() { + + if (library_ == NULL) { + _slow_mutable_library(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.library) + return library_; +} +inline ::tensorflow::FunctionDefLibrary* GraphDef::release_library() { + // @@protoc_insertion_point(field_release:tensorflow.GraphDef.library) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_library(); + } else { + ::tensorflow::FunctionDefLibrary* temp = library_; + library_ = NULL; + return temp; + } +} +inline void GraphDef::set_allocated_library(::tensorflow::FunctionDefLibrary* library) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete library_; + } + if (library != NULL) { + _slow_set_allocated_library(message_arena, &library); + } + library_ = library; + if (library) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDef.library) +} + +inline const GraphDef* GraphDef::internal_default_instance() { + return &GraphDef_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// NodeDef + +// optional string name = 1; +inline void NodeDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& NodeDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void NodeDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.name) +} +inline void NodeDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.name) +} +inline void NodeDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.name) +} +inline ::std::string* NodeDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NodeDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.NodeDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NodeDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void NodeDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.name) +} +inline void NodeDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.name) +} + +// optional string op = 2; +inline void NodeDef::clear_op() { + op_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& NodeDef::op() const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.op) + return op_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void NodeDef::set_op(const ::std::string& value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.op) +} +inline void NodeDef::set_op(const char* value) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.op) +} +inline void NodeDef::set_op(const char* value, + size_t size) { + + op_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.op) +} +inline ::std::string* NodeDef::mutable_op() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.op) + return op_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NodeDef::release_op() { + // @@protoc_insertion_point(field_release:tensorflow.NodeDef.op) + + return op_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NodeDef::unsafe_arena_release_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeDef.op) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return op_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void NodeDef::set_allocated_op(::std::string* op) { + if (op != NULL) { + + } else { + + } + op_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), op, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.op) +} +inline void NodeDef::unsafe_arena_set_allocated_op( + ::std::string* op) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (op != NULL) { + + } else { + + } + op_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + op, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.op) +} + +// repeated string input = 3; +inline int NodeDef::input_size() const { + return input_.size(); +} +inline void NodeDef::clear_input() { + input_.Clear(); +} +inline const ::std::string& NodeDef::input(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.input) + return input_.Get(index); +} +inline ::std::string* NodeDef::mutable_input(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.input) + return input_.Mutable(index); +} +inline void NodeDef::set_input(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.input) + input_.Mutable(index)->assign(value); +} +inline void NodeDef::set_input(int index, const char* value) { + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.input) +} +inline void NodeDef::set_input(int index, const char* value, size_t size) { + input_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.input) +} +inline ::std::string* NodeDef::add_input() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.NodeDef.input) + return input_.Add(); +} +inline void NodeDef::add_input(const ::std::string& value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.NodeDef.input) +} +inline void NodeDef::add_input(const char* value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.NodeDef.input) +} +inline void NodeDef::add_input(const char* value, size_t size) { + input_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.NodeDef.input) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +NodeDef::input() const { + // @@protoc_insertion_point(field_list:tensorflow.NodeDef.input) + return input_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +NodeDef::mutable_input() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeDef.input) + return &input_; +} + +// optional string device = 4; +inline void NodeDef::clear_device() { + device_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& NodeDef::device() const { + // @@protoc_insertion_point(field_get:tensorflow.NodeDef.device) + return device_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void NodeDef::set_device(const ::std::string& value) { + + device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.NodeDef.device) +} +inline void NodeDef::set_device(const char* value) { + + device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.device) +} +inline void NodeDef::set_device(const char* value, + size_t size) { + + device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.device) +} +inline ::std::string* NodeDef::mutable_device() { + + // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.device) + return device_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NodeDef::release_device() { + // @@protoc_insertion_point(field_release:tensorflow.NodeDef.device) + + return device_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* NodeDef::unsafe_arena_release_device() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeDef.device) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return device_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void NodeDef::set_allocated_device(::std::string* device) { + if (device != NULL) { + + } else { + + } + device_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), device, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.device) +} +inline void NodeDef::unsafe_arena_set_allocated_device( + ::std::string* device) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (device != NULL) { + + } else { + + } + device_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + device, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.device) +} + +// map attr = 5; +inline int NodeDef::attr_size() const { + return attr_.size(); +} +inline void NodeDef::clear_attr() { + attr_.Clear(); +} +inline const ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >& +NodeDef::attr() const { + // @@protoc_insertion_point(field_map:tensorflow.NodeDef.attr) + return attr_.GetMap(); +} +inline ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* +NodeDef::mutable_attr() { + // @@protoc_insertion_point(field_mutable_map:tensorflow.NodeDef.attr) + return attr_.MutableMap(); +} + +inline const NodeDef* NodeDef::internal_default_instance() { + return &NodeDef_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_graph_2eproto__INCLUDED diff --git a/modules/dnn/misc/tensorflow/op_def.pb.cc b/modules/dnn/misc/tensorflow/op_def.pb.cc new file mode 100644 index 0000000000..1a9cae3cec --- /dev/null +++ b/modules/dnn/misc/tensorflow/op_def.pb.cc @@ -0,0 +1,4045 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: op_def.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "op_def.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::Descriptor* OpDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + OpDef_reflection_ = NULL; +const ::google::protobuf::Descriptor* OpDef_ArgDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + OpDef_ArgDef_reflection_ = NULL; +const ::google::protobuf::Descriptor* OpDef_AttrDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + OpDef_AttrDef_reflection_ = NULL; +const ::google::protobuf::Descriptor* OpDeprecation_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + OpDeprecation_reflection_ = NULL; +const ::google::protobuf::Descriptor* OpList_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + OpList_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_op_5fdef_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_op_5fdef_2eproto() { + protobuf_AddDesc_op_5fdef_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "op_def.proto"); + GOOGLE_CHECK(file != NULL); + OpDef_descriptor_ = file->message_type(0); + static const int OpDef_offsets_[11] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, input_arg_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, output_arg_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, attr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, deprecation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, summary_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, description_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, is_commutative_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, is_aggregate_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, is_stateful_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, allows_uninitialized_input_), + }; + OpDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + OpDef_descriptor_, + OpDef::internal_default_instance(), + OpDef_offsets_, + -1, + -1, + -1, + sizeof(OpDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef, _internal_metadata_)); + OpDef_ArgDef_descriptor_ = OpDef_descriptor_->nested_type(0); + static const int OpDef_ArgDef_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, description_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, type_attr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, number_attr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, type_list_attr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, is_ref_), + }; + OpDef_ArgDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + OpDef_ArgDef_descriptor_, + OpDef_ArgDef::internal_default_instance(), + OpDef_ArgDef_offsets_, + -1, + -1, + -1, + sizeof(OpDef_ArgDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_ArgDef, _internal_metadata_)); + OpDef_AttrDef_descriptor_ = OpDef_descriptor_->nested_type(1); + static const int OpDef_AttrDef_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, default_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, description_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, has_minimum_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, minimum_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, allowed_values_), + }; + OpDef_AttrDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + OpDef_AttrDef_descriptor_, + OpDef_AttrDef::internal_default_instance(), + OpDef_AttrDef_offsets_, + -1, + -1, + -1, + sizeof(OpDef_AttrDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDef_AttrDef, _internal_metadata_)); + OpDeprecation_descriptor_ = file->message_type(1); + static const int OpDeprecation_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDeprecation, version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDeprecation, explanation_), + }; + OpDeprecation_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + OpDeprecation_descriptor_, + OpDeprecation::internal_default_instance(), + OpDeprecation_offsets_, + -1, + -1, + -1, + sizeof(OpDeprecation), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpDeprecation, _internal_metadata_)); + OpList_descriptor_ = file->message_type(2); + static const int OpList_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpList, op_), + }; + OpList_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + OpList_descriptor_, + OpList::internal_default_instance(), + OpList_offsets_, + -1, + -1, + -1, + sizeof(OpList), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OpList, _internal_metadata_)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_op_5fdef_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + OpDef_descriptor_, OpDef::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + OpDef_ArgDef_descriptor_, OpDef_ArgDef::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + OpDef_AttrDef_descriptor_, OpDef_AttrDef::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + OpDeprecation_descriptor_, OpDeprecation::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + OpList_descriptor_, OpList::internal_default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_op_5fdef_2eproto() { + OpDef_default_instance_.Shutdown(); + delete OpDef_reflection_; + OpDef_ArgDef_default_instance_.Shutdown(); + delete OpDef_ArgDef_reflection_; + OpDef_AttrDef_default_instance_.Shutdown(); + delete OpDef_AttrDef_reflection_; + OpDeprecation_default_instance_.Shutdown(); + delete OpDeprecation_reflection_; + OpList_default_instance_.Shutdown(); + delete OpList_reflection_; +} + +void protobuf_InitDefaults_op_5fdef_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::tensorflow::protobuf_InitDefaults_attr_5fvalue_2eproto(); + ::tensorflow::protobuf_InitDefaults_types_2eproto(); + ::google::protobuf::internal::GetEmptyString(); + OpDef_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + OpDef_ArgDef_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + OpDef_AttrDef_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + OpDeprecation_default_instance_.DefaultConstruct(); + OpList_default_instance_.DefaultConstruct(); + OpDef_default_instance_.get_mutable()->InitAsDefaultInstance(); + OpDef_ArgDef_default_instance_.get_mutable()->InitAsDefaultInstance(); + OpDef_AttrDef_default_instance_.get_mutable()->InitAsDefaultInstance(); + OpDeprecation_default_instance_.get_mutable()->InitAsDefaultInstance(); + OpList_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_op_5fdef_2eproto_once_); +void protobuf_InitDefaults_op_5fdef_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_op_5fdef_2eproto_once_, + &protobuf_InitDefaults_op_5fdef_2eproto_impl); +} +void protobuf_AddDesc_op_5fdef_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_op_5fdef_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\014op_def.proto\022\ntensorflow\032\020attr_value.p" + "roto\032\013types.proto\"\270\005\n\005OpDef\022\014\n\004name\030\001 \001(" + "\t\022+\n\tinput_arg\030\002 \003(\0132\030.tensorflow.OpDef." + "ArgDef\022,\n\noutput_arg\030\003 \003(\0132\030.tensorflow." + "OpDef.ArgDef\022\'\n\004attr\030\004 \003(\0132\031.tensorflow." + "OpDef.AttrDef\022.\n\013deprecation\030\010 \001(\0132\031.ten" + "sorflow.OpDeprecation\022\017\n\007summary\030\005 \001(\t\022\023" + "\n\013description\030\006 \001(\t\022\026\n\016is_commutative\030\022 " + "\001(\010\022\024\n\014is_aggregate\030\020 \001(\010\022\023\n\013is_stateful" + "\030\021 \001(\010\022\"\n\032allows_uninitialized_input\030\023 \001" + "(\010\032\237\001\n\006ArgDef\022\014\n\004name\030\001 \001(\t\022\023\n\013descripti" + "on\030\002 \001(\t\022\"\n\004type\030\003 \001(\0162\024.tensorflow.Data" + "Type\022\021\n\ttype_attr\030\004 \001(\t\022\023\n\013number_attr\030\005" + " \001(\t\022\026\n\016type_list_attr\030\006 \001(\t\022\016\n\006is_ref\030\020" + " \001(\010\032\275\001\n\007AttrDef\022\014\n\004name\030\001 \001(\t\022\014\n\004type\030\002" + " \001(\t\022,\n\rdefault_value\030\003 \001(\0132\025.tensorflow" + ".AttrValue\022\023\n\013description\030\004 \001(\t\022\023\n\013has_m" + "inimum\030\005 \001(\010\022\017\n\007minimum\030\006 \001(\003\022-\n\016allowed" + "_values\030\007 \001(\0132\025.tensorflow.AttrValue\"5\n\r" + "OpDeprecation\022\017\n\007version\030\001 \001(\005\022\023\n\013explan" + "ation\030\002 \001(\t\"\'\n\006OpList\022\035\n\002op\030\001 \003(\0132\021.tens" + "orflow.OpDefB,\n\030org.tensorflow.framework" + "B\013OpDefProtosP\001\370\001\001b\006proto3", 906); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "op_def.proto", &protobuf_RegisterTypes); + ::tensorflow::protobuf_AddDesc_attr_5fvalue_2eproto(); + ::tensorflow::protobuf_AddDesc_types_2eproto(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_op_5fdef_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_op_5fdef_2eproto_once_); +void protobuf_AddDesc_op_5fdef_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_op_5fdef_2eproto_once_, + &protobuf_AddDesc_op_5fdef_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_op_5fdef_2eproto { + StaticDescriptorInitializer_op_5fdef_2eproto() { + protobuf_AddDesc_op_5fdef_2eproto(); + } +} static_descriptor_initializer_op_5fdef_2eproto_; + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int OpDef_ArgDef::kNameFieldNumber; +const int OpDef_ArgDef::kDescriptionFieldNumber; +const int OpDef_ArgDef::kTypeFieldNumber; +const int OpDef_ArgDef::kTypeAttrFieldNumber; +const int OpDef_ArgDef::kNumberAttrFieldNumber; +const int OpDef_ArgDef::kTypeListAttrFieldNumber; +const int OpDef_ArgDef::kIsRefFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +OpDef_ArgDef::OpDef_ArgDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_op_5fdef_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.OpDef.ArgDef) +} +OpDef_ArgDef::OpDef_ArgDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_op_5fdef_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.OpDef.ArgDef) +} + +void OpDef_ArgDef::InitAsDefaultInstance() { +} + +OpDef_ArgDef::OpDef_ArgDef(const OpDef_ArgDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.OpDef.ArgDef) +} + +void OpDef_ArgDef::SharedCtor() { + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_attr_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + number_attr_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_list_attr_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&type_, 0, reinterpret_cast(&is_ref_) - + reinterpret_cast(&type_) + sizeof(is_ref_)); + _cached_size_ = 0; +} + +OpDef_ArgDef::~OpDef_ArgDef() { + // @@protoc_insertion_point(destructor:tensorflow.OpDef.ArgDef) + SharedDtor(); +} + +void OpDef_ArgDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + name_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + description_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + type_attr_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + number_attr_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + type_list_attr_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); +} + +void OpDef_ArgDef::ArenaDtor(void* object) { + OpDef_ArgDef* _this = reinterpret_cast< OpDef_ArgDef* >(object); + (void)_this; +} +void OpDef_ArgDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void OpDef_ArgDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OpDef_ArgDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return OpDef_ArgDef_descriptor_; +} + +const OpDef_ArgDef& OpDef_ArgDef::default_instance() { + protobuf_InitDefaults_op_5fdef_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed OpDef_ArgDef_default_instance_; + +OpDef_ArgDef* OpDef_ArgDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void OpDef_ArgDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.OpDef.ArgDef) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(OpDef_ArgDef, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(type_, is_ref_); + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + type_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + number_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + type_list_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + +#undef ZR_HELPER_ +#undef ZR_ + +} + +bool OpDef_ArgDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.OpDef.ArgDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.ArgDef.name")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_description; + break; + } + + // optional string description = 2; + case 2: { + if (tag == 18) { + parse_description: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_description())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.ArgDef.description")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_type; + break; + } + + // optional .tensorflow.DataType type = 3; + case 3: { + if (tag == 24) { + parse_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_type(static_cast< ::tensorflow::DataType >(value)); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_type_attr; + break; + } + + // optional string type_attr = 4; + case 4: { + if (tag == 34) { + parse_type_attr: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type_attr())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type_attr().data(), this->type_attr().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.ArgDef.type_attr")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_number_attr; + break; + } + + // optional string number_attr = 5; + case 5: { + if (tag == 42) { + parse_number_attr: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_number_attr())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->number_attr().data(), this->number_attr().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.ArgDef.number_attr")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_type_list_attr; + break; + } + + // optional string type_list_attr = 6; + case 6: { + if (tag == 50) { + parse_type_list_attr: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type_list_attr())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type_list_attr().data(), this->type_list_attr().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.ArgDef.type_list_attr")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(128)) goto parse_is_ref; + break; + } + + // optional bool is_ref = 16; + case 16: { + if (tag == 128) { + parse_is_ref: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_ref_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.OpDef.ArgDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.OpDef.ArgDef) + return false; +#undef DO_ +} + +void OpDef_ArgDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.OpDef.ArgDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional string description = 2; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.description"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->description(), output); + } + + // optional .tensorflow.DataType type = 3; + if (this->type() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 3, this->type(), output); + } + + // optional string type_attr = 4; + if (this->type_attr().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type_attr().data(), this->type_attr().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.type_attr"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->type_attr(), output); + } + + // optional string number_attr = 5; + if (this->number_attr().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->number_attr().data(), this->number_attr().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.number_attr"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->number_attr(), output); + } + + // optional string type_list_attr = 6; + if (this->type_list_attr().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type_list_attr().data(), this->type_list_attr().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.type_list_attr"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 6, this->type_list_attr(), output); + } + + // optional bool is_ref = 16; + if (this->is_ref() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->is_ref(), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.OpDef.ArgDef) +} + +::google::protobuf::uint8* OpDef_ArgDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.OpDef.ArgDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional string description = 2; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.description"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->description(), target); + } + + // optional .tensorflow.DataType type = 3; + if (this->type() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 3, this->type(), target); + } + + // optional string type_attr = 4; + if (this->type_attr().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type_attr().data(), this->type_attr().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.type_attr"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->type_attr(), target); + } + + // optional string number_attr = 5; + if (this->number_attr().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->number_attr().data(), this->number_attr().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.number_attr"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->number_attr(), target); + } + + // optional string type_list_attr = 6; + if (this->type_list_attr().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type_list_attr().data(), this->type_list_attr().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.ArgDef.type_list_attr"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->type_list_attr(), target); + } + + // optional bool is_ref = 16; + if (this->is_ref() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->is_ref(), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.OpDef.ArgDef) + return target; +} + +size_t OpDef_ArgDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.OpDef.ArgDef) + size_t total_size = 0; + + // optional string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string description = 2; + if (this->description().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->description()); + } + + // optional .tensorflow.DataType type = 3; + if (this->type() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + // optional string type_attr = 4; + if (this->type_attr().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type_attr()); + } + + // optional string number_attr = 5; + if (this->number_attr().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->number_attr()); + } + + // optional string type_list_attr = 6; + if (this->type_list_attr().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type_list_attr()); + } + + // optional bool is_ref = 16; + if (this->is_ref() != 0) { + total_size += 2 + 1; + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OpDef_ArgDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.OpDef.ArgDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const OpDef_ArgDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.OpDef.ArgDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.OpDef.ArgDef) + UnsafeMergeFrom(*source); + } +} + +void OpDef_ArgDef::MergeFrom(const OpDef_ArgDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.OpDef.ArgDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void OpDef_ArgDef::UnsafeMergeFrom(const OpDef_ArgDef& from) { + GOOGLE_DCHECK(&from != this); + if (from.name().size() > 0) { + set_name(from.name()); + } + if (from.description().size() > 0) { + set_description(from.description()); + } + if (from.type() != 0) { + set_type(from.type()); + } + if (from.type_attr().size() > 0) { + set_type_attr(from.type_attr()); + } + if (from.number_attr().size() > 0) { + set_number_attr(from.number_attr()); + } + if (from.type_list_attr().size() > 0) { + set_type_list_attr(from.type_list_attr()); + } + if (from.is_ref() != 0) { + set_is_ref(from.is_ref()); + } +} + +void OpDef_ArgDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.OpDef.ArgDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OpDef_ArgDef::CopyFrom(const OpDef_ArgDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.OpDef.ArgDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool OpDef_ArgDef::IsInitialized() const { + + return true; +} + +void OpDef_ArgDef::Swap(OpDef_ArgDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + OpDef_ArgDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void OpDef_ArgDef::UnsafeArenaSwap(OpDef_ArgDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void OpDef_ArgDef::InternalSwap(OpDef_ArgDef* other) { + name_.Swap(&other->name_); + description_.Swap(&other->description_); + std::swap(type_, other->type_); + type_attr_.Swap(&other->type_attr_); + number_attr_.Swap(&other->number_attr_); + type_list_attr_.Swap(&other->type_list_attr_); + std::swap(is_ref_, other->is_ref_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata OpDef_ArgDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = OpDef_ArgDef_descriptor_; + metadata.reflection = OpDef_ArgDef_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +void OpDef_AttrDef::_slow_mutable_default_value() { + default_value_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue >( + GetArenaNoVirtual()); +} +::tensorflow::AttrValue* OpDef_AttrDef::_slow_release_default_value() { + if (default_value_ == NULL) { + return NULL; + } else { + ::tensorflow::AttrValue* temp = new ::tensorflow::AttrValue(*default_value_); + default_value_ = NULL; + return temp; + } +} +::tensorflow::AttrValue* OpDef_AttrDef::unsafe_arena_release_default_value() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.default_value) + + ::tensorflow::AttrValue* temp = default_value_; + default_value_ = NULL; + return temp; +} +void OpDef_AttrDef::_slow_set_allocated_default_value( + ::google::protobuf::Arena* message_arena, ::tensorflow::AttrValue** default_value) { + if (message_arena != NULL && + ::google::protobuf::Arena::GetArena(*default_value) == NULL) { + message_arena->Own(*default_value); + } else if (message_arena != + ::google::protobuf::Arena::GetArena(*default_value)) { + ::tensorflow::AttrValue* new_default_value = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue >( + message_arena); + new_default_value->CopyFrom(**default_value); + *default_value = new_default_value; + } +} +void OpDef_AttrDef::unsafe_arena_set_allocated_default_value( + ::tensorflow::AttrValue* default_value) { + if (GetArenaNoVirtual() == NULL) { + delete default_value_; + } + default_value_ = default_value; + if (default_value) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.default_value) +} +void OpDef_AttrDef::_slow_mutable_allowed_values() { + allowed_values_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue >( + GetArenaNoVirtual()); +} +::tensorflow::AttrValue* OpDef_AttrDef::_slow_release_allowed_values() { + if (allowed_values_ == NULL) { + return NULL; + } else { + ::tensorflow::AttrValue* temp = new ::tensorflow::AttrValue(*allowed_values_); + allowed_values_ = NULL; + return temp; + } +} +::tensorflow::AttrValue* OpDef_AttrDef::unsafe_arena_release_allowed_values() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.allowed_values) + + ::tensorflow::AttrValue* temp = allowed_values_; + allowed_values_ = NULL; + return temp; +} +void OpDef_AttrDef::_slow_set_allocated_allowed_values( + ::google::protobuf::Arena* message_arena, ::tensorflow::AttrValue** allowed_values) { + if (message_arena != NULL && + ::google::protobuf::Arena::GetArena(*allowed_values) == NULL) { + message_arena->Own(*allowed_values); + } else if (message_arena != + ::google::protobuf::Arena::GetArena(*allowed_values)) { + ::tensorflow::AttrValue* new_allowed_values = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::AttrValue >( + message_arena); + new_allowed_values->CopyFrom(**allowed_values); + *allowed_values = new_allowed_values; + } +} +void OpDef_AttrDef::unsafe_arena_set_allocated_allowed_values( + ::tensorflow::AttrValue* allowed_values) { + if (GetArenaNoVirtual() == NULL) { + delete allowed_values_; + } + allowed_values_ = allowed_values; + if (allowed_values) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.allowed_values) +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int OpDef_AttrDef::kNameFieldNumber; +const int OpDef_AttrDef::kTypeFieldNumber; +const int OpDef_AttrDef::kDefaultValueFieldNumber; +const int OpDef_AttrDef::kDescriptionFieldNumber; +const int OpDef_AttrDef::kHasMinimumFieldNumber; +const int OpDef_AttrDef::kMinimumFieldNumber; +const int OpDef_AttrDef::kAllowedValuesFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +OpDef_AttrDef::OpDef_AttrDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_op_5fdef_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.OpDef.AttrDef) +} +OpDef_AttrDef::OpDef_AttrDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_op_5fdef_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.OpDef.AttrDef) +} + +void OpDef_AttrDef::InitAsDefaultInstance() { + default_value_ = const_cast< ::tensorflow::AttrValue*>( + ::tensorflow::AttrValue::internal_default_instance()); + allowed_values_ = const_cast< ::tensorflow::AttrValue*>( + ::tensorflow::AttrValue::internal_default_instance()); +} + +OpDef_AttrDef::OpDef_AttrDef(const OpDef_AttrDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.OpDef.AttrDef) +} + +void OpDef_AttrDef::SharedCtor() { + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + default_value_ = NULL; + allowed_values_ = NULL; + ::memset(&minimum_, 0, reinterpret_cast(&has_minimum_) - + reinterpret_cast(&minimum_) + sizeof(has_minimum_)); + _cached_size_ = 0; +} + +OpDef_AttrDef::~OpDef_AttrDef() { + // @@protoc_insertion_point(destructor:tensorflow.OpDef.AttrDef) + SharedDtor(); +} + +void OpDef_AttrDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + name_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + type_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + description_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + if (this != &OpDef_AttrDef_default_instance_.get()) { + delete default_value_; + delete allowed_values_; + } +} + +void OpDef_AttrDef::ArenaDtor(void* object) { + OpDef_AttrDef* _this = reinterpret_cast< OpDef_AttrDef* >(object); + (void)_this; +} +void OpDef_AttrDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void OpDef_AttrDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OpDef_AttrDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return OpDef_AttrDef_descriptor_; +} + +const OpDef_AttrDef& OpDef_AttrDef::default_instance() { + protobuf_InitDefaults_op_5fdef_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed OpDef_AttrDef_default_instance_; + +OpDef_AttrDef* OpDef_AttrDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void OpDef_AttrDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.OpDef.AttrDef) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(OpDef_AttrDef, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(minimum_, has_minimum_); + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + type_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + if (GetArenaNoVirtual() == NULL && default_value_ != NULL) delete default_value_; + default_value_ = NULL; + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + if (GetArenaNoVirtual() == NULL && allowed_values_ != NULL) delete allowed_values_; + allowed_values_ = NULL; + +#undef ZR_HELPER_ +#undef ZR_ + +} + +bool OpDef_AttrDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.OpDef.AttrDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.AttrDef.name")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_type; + break; + } + + // optional string type = 2; + case 2: { + if (tag == 18) { + parse_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.AttrDef.type")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_default_value; + break; + } + + // optional .tensorflow.AttrValue default_value = 3; + case 3: { + if (tag == 26) { + parse_default_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_default_value())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_description; + break; + } + + // optional string description = 4; + case 4: { + if (tag == 34) { + parse_description: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_description())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.AttrDef.description")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_has_minimum; + break; + } + + // optional bool has_minimum = 5; + case 5: { + if (tag == 40) { + parse_has_minimum: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &has_minimum_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_minimum; + break; + } + + // optional int64 minimum = 6; + case 6: { + if (tag == 48) { + parse_minimum: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &minimum_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_allowed_values; + break; + } + + // optional .tensorflow.AttrValue allowed_values = 7; + case 7: { + if (tag == 58) { + parse_allowed_values: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_allowed_values())); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.OpDef.AttrDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.OpDef.AttrDef) + return false; +#undef DO_ +} + +void OpDef_AttrDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.OpDef.AttrDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.AttrDef.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional string type = 2; + if (this->type().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.AttrDef.type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->type(), output); + } + + // optional .tensorflow.AttrValue default_value = 3; + if (this->has_default_value()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, *this->default_value_, output); + } + + // optional string description = 4; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.AttrDef.description"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->description(), output); + } + + // optional bool has_minimum = 5; + if (this->has_minimum() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->has_minimum(), output); + } + + // optional int64 minimum = 6; + if (this->minimum() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->minimum(), output); + } + + // optional .tensorflow.AttrValue allowed_values = 7; + if (this->has_allowed_values()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, *this->allowed_values_, output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.OpDef.AttrDef) +} + +::google::protobuf::uint8* OpDef_AttrDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.OpDef.AttrDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.AttrDef.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional string type = 2; + if (this->type().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.AttrDef.type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->type(), target); + } + + // optional .tensorflow.AttrValue default_value = 3; + if (this->has_default_value()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 3, *this->default_value_, false, target); + } + + // optional string description = 4; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.AttrDef.description"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->description(), target); + } + + // optional bool has_minimum = 5; + if (this->has_minimum() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->has_minimum(), target); + } + + // optional int64 minimum = 6; + if (this->minimum() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->minimum(), target); + } + + // optional .tensorflow.AttrValue allowed_values = 7; + if (this->has_allowed_values()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 7, *this->allowed_values_, false, target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.OpDef.AttrDef) + return target; +} + +size_t OpDef_AttrDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.OpDef.AttrDef) + size_t total_size = 0; + + // optional string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string type = 2; + if (this->type().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + // optional .tensorflow.AttrValue default_value = 3; + if (this->has_default_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->default_value_); + } + + // optional string description = 4; + if (this->description().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->description()); + } + + // optional bool has_minimum = 5; + if (this->has_minimum() != 0) { + total_size += 1 + 1; + } + + // optional int64 minimum = 6; + if (this->minimum() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->minimum()); + } + + // optional .tensorflow.AttrValue allowed_values = 7; + if (this->has_allowed_values()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->allowed_values_); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OpDef_AttrDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.OpDef.AttrDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const OpDef_AttrDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.OpDef.AttrDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.OpDef.AttrDef) + UnsafeMergeFrom(*source); + } +} + +void OpDef_AttrDef::MergeFrom(const OpDef_AttrDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.OpDef.AttrDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void OpDef_AttrDef::UnsafeMergeFrom(const OpDef_AttrDef& from) { + GOOGLE_DCHECK(&from != this); + if (from.name().size() > 0) { + set_name(from.name()); + } + if (from.type().size() > 0) { + set_type(from.type()); + } + if (from.has_default_value()) { + mutable_default_value()->::tensorflow::AttrValue::MergeFrom(from.default_value()); + } + if (from.description().size() > 0) { + set_description(from.description()); + } + if (from.has_minimum() != 0) { + set_has_minimum(from.has_minimum()); + } + if (from.minimum() != 0) { + set_minimum(from.minimum()); + } + if (from.has_allowed_values()) { + mutable_allowed_values()->::tensorflow::AttrValue::MergeFrom(from.allowed_values()); + } +} + +void OpDef_AttrDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.OpDef.AttrDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OpDef_AttrDef::CopyFrom(const OpDef_AttrDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.OpDef.AttrDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool OpDef_AttrDef::IsInitialized() const { + + return true; +} + +void OpDef_AttrDef::Swap(OpDef_AttrDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + OpDef_AttrDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void OpDef_AttrDef::UnsafeArenaSwap(OpDef_AttrDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void OpDef_AttrDef::InternalSwap(OpDef_AttrDef* other) { + name_.Swap(&other->name_); + type_.Swap(&other->type_); + std::swap(default_value_, other->default_value_); + description_.Swap(&other->description_); + std::swap(has_minimum_, other->has_minimum_); + std::swap(minimum_, other->minimum_); + std::swap(allowed_values_, other->allowed_values_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata OpDef_AttrDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = OpDef_AttrDef_descriptor_; + metadata.reflection = OpDef_AttrDef_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +void OpDef::_slow_mutable_deprecation() { + deprecation_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::OpDeprecation >( + GetArenaNoVirtual()); +} +::tensorflow::OpDeprecation* OpDef::_slow_release_deprecation() { + if (deprecation_ == NULL) { + return NULL; + } else { + ::tensorflow::OpDeprecation* temp = new ::tensorflow::OpDeprecation(*deprecation_); + deprecation_ = NULL; + return temp; + } +} +::tensorflow::OpDeprecation* OpDef::unsafe_arena_release_deprecation() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.deprecation) + + ::tensorflow::OpDeprecation* temp = deprecation_; + deprecation_ = NULL; + return temp; +} +void OpDef::_slow_set_allocated_deprecation( + ::google::protobuf::Arena* message_arena, ::tensorflow::OpDeprecation** deprecation) { + if (message_arena != NULL && + ::google::protobuf::Arena::GetArena(*deprecation) == NULL) { + message_arena->Own(*deprecation); + } else if (message_arena != + ::google::protobuf::Arena::GetArena(*deprecation)) { + ::tensorflow::OpDeprecation* new_deprecation = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::OpDeprecation >( + message_arena); + new_deprecation->CopyFrom(**deprecation); + *deprecation = new_deprecation; + } +} +void OpDef::unsafe_arena_set_allocated_deprecation( + ::tensorflow::OpDeprecation* deprecation) { + if (GetArenaNoVirtual() == NULL) { + delete deprecation_; + } + deprecation_ = deprecation; + if (deprecation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.deprecation) +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int OpDef::kNameFieldNumber; +const int OpDef::kInputArgFieldNumber; +const int OpDef::kOutputArgFieldNumber; +const int OpDef::kAttrFieldNumber; +const int OpDef::kDeprecationFieldNumber; +const int OpDef::kSummaryFieldNumber; +const int OpDef::kDescriptionFieldNumber; +const int OpDef::kIsCommutativeFieldNumber; +const int OpDef::kIsAggregateFieldNumber; +const int OpDef::kIsStatefulFieldNumber; +const int OpDef::kAllowsUninitializedInputFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +OpDef::OpDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_op_5fdef_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.OpDef) +} +OpDef::OpDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + input_arg_(arena), + output_arg_(arena), + attr_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_op_5fdef_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.OpDef) +} + +void OpDef::InitAsDefaultInstance() { + deprecation_ = const_cast< ::tensorflow::OpDeprecation*>( + ::tensorflow::OpDeprecation::internal_default_instance()); +} + +OpDef::OpDef(const OpDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.OpDef) +} + +void OpDef::SharedCtor() { + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + summary_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + deprecation_ = NULL; + ::memset(&is_commutative_, 0, reinterpret_cast(&allows_uninitialized_input_) - + reinterpret_cast(&is_commutative_) + sizeof(allows_uninitialized_input_)); + _cached_size_ = 0; +} + +OpDef::~OpDef() { + // @@protoc_insertion_point(destructor:tensorflow.OpDef) + SharedDtor(); +} + +void OpDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + name_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + summary_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + description_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + if (this != &OpDef_default_instance_.get()) { + delete deprecation_; + } +} + +void OpDef::ArenaDtor(void* object) { + OpDef* _this = reinterpret_cast< OpDef* >(object); + (void)_this; +} +void OpDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void OpDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OpDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return OpDef_descriptor_; +} + +const OpDef& OpDef::default_instance() { + protobuf_InitDefaults_op_5fdef_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed OpDef_default_instance_; + +OpDef* OpDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void OpDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.OpDef) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(OpDef, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + if (GetArenaNoVirtual() == NULL && deprecation_ != NULL) delete deprecation_; + deprecation_ = NULL; + summary_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + is_commutative_ = false; + ZR_(is_aggregate_, allows_uninitialized_input_); + +#undef ZR_HELPER_ +#undef ZR_ + + input_arg_.Clear(); + output_arg_.Clear(); + attr_.Clear(); +} + +bool OpDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.OpDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.name")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_input_arg; + break; + } + + // repeated .tensorflow.OpDef.ArgDef input_arg = 2; + case 2: { + if (tag == 18) { + parse_input_arg: + DO_(input->IncrementRecursionDepth()); + parse_loop_input_arg: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_input_arg())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_loop_input_arg; + if (input->ExpectTag(26)) goto parse_loop_output_arg; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .tensorflow.OpDef.ArgDef output_arg = 3; + case 3: { + if (tag == 26) { + DO_(input->IncrementRecursionDepth()); + parse_loop_output_arg: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_output_arg())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_loop_output_arg; + if (input->ExpectTag(34)) goto parse_loop_attr; + input->UnsafeDecrementRecursionDepth(); + break; + } + + // repeated .tensorflow.OpDef.AttrDef attr = 4; + case 4: { + if (tag == 34) { + DO_(input->IncrementRecursionDepth()); + parse_loop_attr: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_attr())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_loop_attr; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(42)) goto parse_summary; + break; + } + + // optional string summary = 5; + case 5: { + if (tag == 42) { + parse_summary: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_summary())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->summary().data(), this->summary().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.summary")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_description; + break; + } + + // optional string description = 6; + case 6: { + if (tag == 50) { + parse_description: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_description())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDef.description")); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_deprecation; + break; + } + + // optional .tensorflow.OpDeprecation deprecation = 8; + case 8: { + if (tag == 66) { + parse_deprecation: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_deprecation())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(128)) goto parse_is_aggregate; + break; + } + + // optional bool is_aggregate = 16; + case 16: { + if (tag == 128) { + parse_is_aggregate: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_aggregate_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(136)) goto parse_is_stateful; + break; + } + + // optional bool is_stateful = 17; + case 17: { + if (tag == 136) { + parse_is_stateful: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_stateful_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(144)) goto parse_is_commutative; + break; + } + + // optional bool is_commutative = 18; + case 18: { + if (tag == 144) { + parse_is_commutative: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_commutative_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(152)) goto parse_allows_uninitialized_input; + break; + } + + // optional bool allows_uninitialized_input = 19; + case 19: { + if (tag == 152) { + parse_allows_uninitialized_input: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &allows_uninitialized_input_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.OpDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.OpDef) + return false; +#undef DO_ +} + +void OpDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.OpDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // repeated .tensorflow.OpDef.ArgDef input_arg = 2; + for (unsigned int i = 0, n = this->input_arg_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->input_arg(i), output); + } + + // repeated .tensorflow.OpDef.ArgDef output_arg = 3; + for (unsigned int i = 0, n = this->output_arg_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->output_arg(i), output); + } + + // repeated .tensorflow.OpDef.AttrDef attr = 4; + for (unsigned int i = 0, n = this->attr_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->attr(i), output); + } + + // optional string summary = 5; + if (this->summary().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->summary().data(), this->summary().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.summary"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->summary(), output); + } + + // optional string description = 6; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.description"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 6, this->description(), output); + } + + // optional .tensorflow.OpDeprecation deprecation = 8; + if (this->has_deprecation()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, *this->deprecation_, output); + } + + // optional bool is_aggregate = 16; + if (this->is_aggregate() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->is_aggregate(), output); + } + + // optional bool is_stateful = 17; + if (this->is_stateful() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->is_stateful(), output); + } + + // optional bool is_commutative = 18; + if (this->is_commutative() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(18, this->is_commutative(), output); + } + + // optional bool allows_uninitialized_input = 19; + if (this->allows_uninitialized_input() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(19, this->allows_uninitialized_input(), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.OpDef) +} + +::google::protobuf::uint8* OpDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.OpDef) + // optional string name = 1; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // repeated .tensorflow.OpDef.ArgDef input_arg = 2; + for (unsigned int i = 0, n = this->input_arg_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, this->input_arg(i), false, target); + } + + // repeated .tensorflow.OpDef.ArgDef output_arg = 3; + for (unsigned int i = 0, n = this->output_arg_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 3, this->output_arg(i), false, target); + } + + // repeated .tensorflow.OpDef.AttrDef attr = 4; + for (unsigned int i = 0, n = this->attr_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 4, this->attr(i), false, target); + } + + // optional string summary = 5; + if (this->summary().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->summary().data(), this->summary().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.summary"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->summary(), target); + } + + // optional string description = 6; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), this->description().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDef.description"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->description(), target); + } + + // optional .tensorflow.OpDeprecation deprecation = 8; + if (this->has_deprecation()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 8, *this->deprecation_, false, target); + } + + // optional bool is_aggregate = 16; + if (this->is_aggregate() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->is_aggregate(), target); + } + + // optional bool is_stateful = 17; + if (this->is_stateful() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->is_stateful(), target); + } + + // optional bool is_commutative = 18; + if (this->is_commutative() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(18, this->is_commutative(), target); + } + + // optional bool allows_uninitialized_input = 19; + if (this->allows_uninitialized_input() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(19, this->allows_uninitialized_input(), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.OpDef) + return target; +} + +size_t OpDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.OpDef) + size_t total_size = 0; + + // optional string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional .tensorflow.OpDeprecation deprecation = 8; + if (this->has_deprecation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->deprecation_); + } + + // optional string summary = 5; + if (this->summary().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->summary()); + } + + // optional string description = 6; + if (this->description().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->description()); + } + + // optional bool is_commutative = 18; + if (this->is_commutative() != 0) { + total_size += 2 + 1; + } + + // optional bool is_aggregate = 16; + if (this->is_aggregate() != 0) { + total_size += 2 + 1; + } + + // optional bool is_stateful = 17; + if (this->is_stateful() != 0) { + total_size += 2 + 1; + } + + // optional bool allows_uninitialized_input = 19; + if (this->allows_uninitialized_input() != 0) { + total_size += 2 + 1; + } + + // repeated .tensorflow.OpDef.ArgDef input_arg = 2; + { + unsigned int count = this->input_arg_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->input_arg(i)); + } + } + + // repeated .tensorflow.OpDef.ArgDef output_arg = 3; + { + unsigned int count = this->output_arg_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->output_arg(i)); + } + } + + // repeated .tensorflow.OpDef.AttrDef attr = 4; + { + unsigned int count = this->attr_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attr(i)); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OpDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.OpDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const OpDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.OpDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.OpDef) + UnsafeMergeFrom(*source); + } +} + +void OpDef::MergeFrom(const OpDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.OpDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void OpDef::UnsafeMergeFrom(const OpDef& from) { + GOOGLE_DCHECK(&from != this); + input_arg_.MergeFrom(from.input_arg_); + output_arg_.MergeFrom(from.output_arg_); + attr_.MergeFrom(from.attr_); + if (from.name().size() > 0) { + set_name(from.name()); + } + if (from.has_deprecation()) { + mutable_deprecation()->::tensorflow::OpDeprecation::MergeFrom(from.deprecation()); + } + if (from.summary().size() > 0) { + set_summary(from.summary()); + } + if (from.description().size() > 0) { + set_description(from.description()); + } + if (from.is_commutative() != 0) { + set_is_commutative(from.is_commutative()); + } + if (from.is_aggregate() != 0) { + set_is_aggregate(from.is_aggregate()); + } + if (from.is_stateful() != 0) { + set_is_stateful(from.is_stateful()); + } + if (from.allows_uninitialized_input() != 0) { + set_allows_uninitialized_input(from.allows_uninitialized_input()); + } +} + +void OpDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.OpDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OpDef::CopyFrom(const OpDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.OpDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool OpDef::IsInitialized() const { + + return true; +} + +void OpDef::Swap(OpDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + OpDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void OpDef::UnsafeArenaSwap(OpDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void OpDef::InternalSwap(OpDef* other) { + name_.Swap(&other->name_); + input_arg_.UnsafeArenaSwap(&other->input_arg_); + output_arg_.UnsafeArenaSwap(&other->output_arg_); + attr_.UnsafeArenaSwap(&other->attr_); + std::swap(deprecation_, other->deprecation_); + summary_.Swap(&other->summary_); + description_.Swap(&other->description_); + std::swap(is_commutative_, other->is_commutative_); + std::swap(is_aggregate_, other->is_aggregate_); + std::swap(is_stateful_, other->is_stateful_); + std::swap(allows_uninitialized_input_, other->allows_uninitialized_input_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata OpDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = OpDef_descriptor_; + metadata.reflection = OpDef_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// OpDef_ArgDef + +// optional string name = 1; +void OpDef_ArgDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_ArgDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_ArgDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.name) +} +void OpDef_ArgDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.name) +} +void OpDef_ArgDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.name) +} +::std::string* OpDef_ArgDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_ArgDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.name) +} +void OpDef_ArgDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.name) +} + +// optional string description = 2; +void OpDef_ArgDef::clear_description() { + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_ArgDef::description() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.description) + return description_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_ArgDef::set_description(const ::std::string& value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.description) +} +void OpDef_ArgDef::set_description(const char* value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.description) +} +void OpDef_ArgDef::set_description(const char* value, + size_t size) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.description) +} +::std::string* OpDef_ArgDef::mutable_description() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.description) + return description_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::release_description() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.description) + + return description_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.description) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return description_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_ArgDef::set_allocated_description(::std::string* description) { + if (description != NULL) { + + } else { + + } + description_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.description) +} +void OpDef_ArgDef::unsafe_arena_set_allocated_description( + ::std::string* description) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (description != NULL) { + + } else { + + } + description_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + description, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.description) +} + +// optional .tensorflow.DataType type = 3; +void OpDef_ArgDef::clear_type() { + type_ = 0; +} +::tensorflow::DataType OpDef_ArgDef::type() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type) + return static_cast< ::tensorflow::DataType >(type_); +} +void OpDef_ArgDef::set_type(::tensorflow::DataType value) { + + type_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type) +} + +// optional string type_attr = 4; +void OpDef_ArgDef::clear_type_attr() { + type_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_ArgDef::type_attr() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_attr) + return type_attr_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_ArgDef::set_type_attr(const ::std::string& value) { + + type_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_attr) +} +void OpDef_ArgDef::set_type_attr(const char* value) { + + type_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.type_attr) +} +void OpDef_ArgDef::set_type_attr(const char* value, + size_t size) { + + type_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.type_attr) +} +::std::string* OpDef_ArgDef::mutable_type_attr() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_attr) + return type_attr_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::release_type_attr() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_attr) + + return type_attr_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::unsafe_arena_release_type_attr() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.type_attr) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return type_attr_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_ArgDef::set_allocated_type_attr(::std::string* type_attr) { + if (type_attr != NULL) { + + } else { + + } + type_attr_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_attr, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_attr) +} +void OpDef_ArgDef::unsafe_arena_set_allocated_type_attr( + ::std::string* type_attr) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (type_attr != NULL) { + + } else { + + } + type_attr_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + type_attr, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.type_attr) +} + +// optional string number_attr = 5; +void OpDef_ArgDef::clear_number_attr() { + number_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_ArgDef::number_attr() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.number_attr) + return number_attr_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_ArgDef::set_number_attr(const ::std::string& value) { + + number_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.number_attr) +} +void OpDef_ArgDef::set_number_attr(const char* value) { + + number_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.number_attr) +} +void OpDef_ArgDef::set_number_attr(const char* value, + size_t size) { + + number_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.number_attr) +} +::std::string* OpDef_ArgDef::mutable_number_attr() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.number_attr) + return number_attr_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::release_number_attr() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.number_attr) + + return number_attr_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::unsafe_arena_release_number_attr() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.number_attr) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return number_attr_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_ArgDef::set_allocated_number_attr(::std::string* number_attr) { + if (number_attr != NULL) { + + } else { + + } + number_attr_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), number_attr, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.number_attr) +} +void OpDef_ArgDef::unsafe_arena_set_allocated_number_attr( + ::std::string* number_attr) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (number_attr != NULL) { + + } else { + + } + number_attr_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + number_attr, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.number_attr) +} + +// optional string type_list_attr = 6; +void OpDef_ArgDef::clear_type_list_attr() { + type_list_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_ArgDef::type_list_attr() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_list_attr) + return type_list_attr_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_ArgDef::set_type_list_attr(const ::std::string& value) { + + type_list_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_list_attr) +} +void OpDef_ArgDef::set_type_list_attr(const char* value) { + + type_list_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.type_list_attr) +} +void OpDef_ArgDef::set_type_list_attr(const char* value, + size_t size) { + + type_list_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.type_list_attr) +} +::std::string* OpDef_ArgDef::mutable_type_list_attr() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_list_attr) + return type_list_attr_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::release_type_list_attr() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_list_attr) + + return type_list_attr_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_ArgDef::unsafe_arena_release_type_list_attr() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.type_list_attr) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return type_list_attr_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_ArgDef::set_allocated_type_list_attr(::std::string* type_list_attr) { + if (type_list_attr != NULL) { + + } else { + + } + type_list_attr_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_list_attr, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_list_attr) +} +void OpDef_ArgDef::unsafe_arena_set_allocated_type_list_attr( + ::std::string* type_list_attr) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (type_list_attr != NULL) { + + } else { + + } + type_list_attr_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + type_list_attr, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.type_list_attr) +} + +// optional bool is_ref = 16; +void OpDef_ArgDef::clear_is_ref() { + is_ref_ = false; +} +bool OpDef_ArgDef::is_ref() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.is_ref) + return is_ref_; +} +void OpDef_ArgDef::set_is_ref(bool value) { + + is_ref_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.is_ref) +} + +inline const OpDef_ArgDef* OpDef_ArgDef::internal_default_instance() { + return &OpDef_ArgDef_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// OpDef_AttrDef + +// optional string name = 1; +void OpDef_AttrDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_AttrDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_AttrDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.name) +} +void OpDef_AttrDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.AttrDef.name) +} +void OpDef_AttrDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.AttrDef.name) +} +::std::string* OpDef_AttrDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_AttrDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_AttrDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_AttrDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.name) +} +void OpDef_AttrDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.name) +} + +// optional string type = 2; +void OpDef_AttrDef::clear_type() { + type_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_AttrDef::type() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.type) + return type_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_AttrDef::set_type(const ::std::string& value) { + + type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.type) +} +void OpDef_AttrDef::set_type(const char* value) { + + type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.AttrDef.type) +} +void OpDef_AttrDef::set_type(const char* value, + size_t size) { + + type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.AttrDef.type) +} +::std::string* OpDef_AttrDef::mutable_type() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.type) + return type_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_AttrDef::release_type() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.type) + + return type_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_AttrDef::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.type) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return type_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_AttrDef::set_allocated_type(::std::string* type) { + if (type != NULL) { + + } else { + + } + type_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.type) +} +void OpDef_AttrDef::unsafe_arena_set_allocated_type( + ::std::string* type) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (type != NULL) { + + } else { + + } + type_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + type, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.type) +} + +// optional .tensorflow.AttrValue default_value = 3; +bool OpDef_AttrDef::has_default_value() const { + return this != internal_default_instance() && default_value_ != NULL; +} +void OpDef_AttrDef::clear_default_value() { + if (GetArenaNoVirtual() == NULL && default_value_ != NULL) delete default_value_; + default_value_ = NULL; +} +const ::tensorflow::AttrValue& OpDef_AttrDef::default_value() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.default_value) + return default_value_ != NULL ? *default_value_ + : *::tensorflow::AttrValue::internal_default_instance(); +} +::tensorflow::AttrValue* OpDef_AttrDef::mutable_default_value() { + + if (default_value_ == NULL) { + _slow_mutable_default_value(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.default_value) + return default_value_; +} +::tensorflow::AttrValue* OpDef_AttrDef::release_default_value() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.default_value) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_default_value(); + } else { + ::tensorflow::AttrValue* temp = default_value_; + default_value_ = NULL; + return temp; + } +} + void OpDef_AttrDef::set_allocated_default_value(::tensorflow::AttrValue* default_value) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete default_value_; + } + if (default_value != NULL) { + _slow_set_allocated_default_value(message_arena, &default_value); + } + default_value_ = default_value; + if (default_value) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.default_value) +} + +// optional string description = 4; +void OpDef_AttrDef::clear_description() { + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef_AttrDef::description() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.description) + return description_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef_AttrDef::set_description(const ::std::string& value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.description) +} +void OpDef_AttrDef::set_description(const char* value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.AttrDef.description) +} +void OpDef_AttrDef::set_description(const char* value, + size_t size) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.AttrDef.description) +} +::std::string* OpDef_AttrDef::mutable_description() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.description) + return description_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_AttrDef::release_description() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.description) + + return description_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef_AttrDef::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.description) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return description_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef_AttrDef::set_allocated_description(::std::string* description) { + if (description != NULL) { + + } else { + + } + description_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.description) +} +void OpDef_AttrDef::unsafe_arena_set_allocated_description( + ::std::string* description) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (description != NULL) { + + } else { + + } + description_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + description, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.description) +} + +// optional bool has_minimum = 5; +void OpDef_AttrDef::clear_has_minimum() { + has_minimum_ = false; +} +bool OpDef_AttrDef::has_minimum() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.has_minimum) + return has_minimum_; +} +void OpDef_AttrDef::set_has_minimum(bool value) { + + has_minimum_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.has_minimum) +} + +// optional int64 minimum = 6; +void OpDef_AttrDef::clear_minimum() { + minimum_ = GOOGLE_LONGLONG(0); +} +::google::protobuf::int64 OpDef_AttrDef::minimum() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.minimum) + return minimum_; +} +void OpDef_AttrDef::set_minimum(::google::protobuf::int64 value) { + + minimum_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.minimum) +} + +// optional .tensorflow.AttrValue allowed_values = 7; +bool OpDef_AttrDef::has_allowed_values() const { + return this != internal_default_instance() && allowed_values_ != NULL; +} +void OpDef_AttrDef::clear_allowed_values() { + if (GetArenaNoVirtual() == NULL && allowed_values_ != NULL) delete allowed_values_; + allowed_values_ = NULL; +} +const ::tensorflow::AttrValue& OpDef_AttrDef::allowed_values() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.allowed_values) + return allowed_values_ != NULL ? *allowed_values_ + : *::tensorflow::AttrValue::internal_default_instance(); +} +::tensorflow::AttrValue* OpDef_AttrDef::mutable_allowed_values() { + + if (allowed_values_ == NULL) { + _slow_mutable_allowed_values(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.allowed_values) + return allowed_values_; +} +::tensorflow::AttrValue* OpDef_AttrDef::release_allowed_values() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.allowed_values) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_allowed_values(); + } else { + ::tensorflow::AttrValue* temp = allowed_values_; + allowed_values_ = NULL; + return temp; + } +} + void OpDef_AttrDef::set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete allowed_values_; + } + if (allowed_values != NULL) { + _slow_set_allocated_allowed_values(message_arena, &allowed_values); + } + allowed_values_ = allowed_values; + if (allowed_values) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.allowed_values) +} + +inline const OpDef_AttrDef* OpDef_AttrDef::internal_default_instance() { + return &OpDef_AttrDef_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// OpDef + +// optional string name = 1; +void OpDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.name) +} +void OpDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.name) +} +void OpDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.name) +} +::std::string* OpDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.name) +} +void OpDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.name) +} + +// repeated .tensorflow.OpDef.ArgDef input_arg = 2; +int OpDef::input_arg_size() const { + return input_arg_.size(); +} +void OpDef::clear_input_arg() { + input_arg_.Clear(); +} +const ::tensorflow::OpDef_ArgDef& OpDef::input_arg(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.input_arg) + return input_arg_.Get(index); +} +::tensorflow::OpDef_ArgDef* OpDef::mutable_input_arg(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.input_arg) + return input_arg_.Mutable(index); +} +::tensorflow::OpDef_ArgDef* OpDef::add_input_arg() { + // @@protoc_insertion_point(field_add:tensorflow.OpDef.input_arg) + return input_arg_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >* +OpDef::mutable_input_arg() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.input_arg) + return &input_arg_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >& +OpDef::input_arg() const { + // @@protoc_insertion_point(field_list:tensorflow.OpDef.input_arg) + return input_arg_; +} + +// repeated .tensorflow.OpDef.ArgDef output_arg = 3; +int OpDef::output_arg_size() const { + return output_arg_.size(); +} +void OpDef::clear_output_arg() { + output_arg_.Clear(); +} +const ::tensorflow::OpDef_ArgDef& OpDef::output_arg(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.output_arg) + return output_arg_.Get(index); +} +::tensorflow::OpDef_ArgDef* OpDef::mutable_output_arg(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.output_arg) + return output_arg_.Mutable(index); +} +::tensorflow::OpDef_ArgDef* OpDef::add_output_arg() { + // @@protoc_insertion_point(field_add:tensorflow.OpDef.output_arg) + return output_arg_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >* +OpDef::mutable_output_arg() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.output_arg) + return &output_arg_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >& +OpDef::output_arg() const { + // @@protoc_insertion_point(field_list:tensorflow.OpDef.output_arg) + return output_arg_; +} + +// repeated .tensorflow.OpDef.AttrDef attr = 4; +int OpDef::attr_size() const { + return attr_.size(); +} +void OpDef::clear_attr() { + attr_.Clear(); +} +const ::tensorflow::OpDef_AttrDef& OpDef::attr(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.attr) + return attr_.Get(index); +} +::tensorflow::OpDef_AttrDef* OpDef::mutable_attr(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.attr) + return attr_.Mutable(index); +} +::tensorflow::OpDef_AttrDef* OpDef::add_attr() { + // @@protoc_insertion_point(field_add:tensorflow.OpDef.attr) + return attr_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >* +OpDef::mutable_attr() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.attr) + return &attr_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >& +OpDef::attr() const { + // @@protoc_insertion_point(field_list:tensorflow.OpDef.attr) + return attr_; +} + +// optional .tensorflow.OpDeprecation deprecation = 8; +bool OpDef::has_deprecation() const { + return this != internal_default_instance() && deprecation_ != NULL; +} +void OpDef::clear_deprecation() { + if (GetArenaNoVirtual() == NULL && deprecation_ != NULL) delete deprecation_; + deprecation_ = NULL; +} +const ::tensorflow::OpDeprecation& OpDef::deprecation() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.deprecation) + return deprecation_ != NULL ? *deprecation_ + : *::tensorflow::OpDeprecation::internal_default_instance(); +} +::tensorflow::OpDeprecation* OpDef::mutable_deprecation() { + + if (deprecation_ == NULL) { + _slow_mutable_deprecation(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.deprecation) + return deprecation_; +} +::tensorflow::OpDeprecation* OpDef::release_deprecation() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.deprecation) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_deprecation(); + } else { + ::tensorflow::OpDeprecation* temp = deprecation_; + deprecation_ = NULL; + return temp; + } +} + void OpDef::set_allocated_deprecation(::tensorflow::OpDeprecation* deprecation) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete deprecation_; + } + if (deprecation != NULL) { + _slow_set_allocated_deprecation(message_arena, &deprecation); + } + deprecation_ = deprecation; + if (deprecation) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.deprecation) +} + +// optional string summary = 5; +void OpDef::clear_summary() { + summary_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef::summary() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.summary) + return summary_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef::set_summary(const ::std::string& value) { + + summary_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.summary) +} +void OpDef::set_summary(const char* value) { + + summary_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.summary) +} +void OpDef::set_summary(const char* value, + size_t size) { + + summary_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.summary) +} +::std::string* OpDef::mutable_summary() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.summary) + return summary_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef::release_summary() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.summary) + + return summary_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef::unsafe_arena_release_summary() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.summary) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return summary_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef::set_allocated_summary(::std::string* summary) { + if (summary != NULL) { + + } else { + + } + summary_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), summary, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.summary) +} +void OpDef::unsafe_arena_set_allocated_summary( + ::std::string* summary) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (summary != NULL) { + + } else { + + } + summary_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + summary, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.summary) +} + +// optional string description = 6; +void OpDef::clear_description() { + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDef::description() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.description) + return description_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDef::set_description(const ::std::string& value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.description) +} +void OpDef::set_description(const char* value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.description) +} +void OpDef::set_description(const char* value, + size_t size) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.description) +} +::std::string* OpDef::mutable_description() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.description) + return description_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef::release_description() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.description) + + return description_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDef::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.description) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return description_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDef::set_allocated_description(::std::string* description) { + if (description != NULL) { + + } else { + + } + description_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.description) +} +void OpDef::unsafe_arena_set_allocated_description( + ::std::string* description) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (description != NULL) { + + } else { + + } + description_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + description, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.description) +} + +// optional bool is_commutative = 18; +void OpDef::clear_is_commutative() { + is_commutative_ = false; +} +bool OpDef::is_commutative() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_commutative) + return is_commutative_; +} +void OpDef::set_is_commutative(bool value) { + + is_commutative_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_commutative) +} + +// optional bool is_aggregate = 16; +void OpDef::clear_is_aggregate() { + is_aggregate_ = false; +} +bool OpDef::is_aggregate() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_aggregate) + return is_aggregate_; +} +void OpDef::set_is_aggregate(bool value) { + + is_aggregate_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_aggregate) +} + +// optional bool is_stateful = 17; +void OpDef::clear_is_stateful() { + is_stateful_ = false; +} +bool OpDef::is_stateful() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_stateful) + return is_stateful_; +} +void OpDef::set_is_stateful(bool value) { + + is_stateful_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_stateful) +} + +// optional bool allows_uninitialized_input = 19; +void OpDef::clear_allows_uninitialized_input() { + allows_uninitialized_input_ = false; +} +bool OpDef::allows_uninitialized_input() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.allows_uninitialized_input) + return allows_uninitialized_input_; +} +void OpDef::set_allows_uninitialized_input(bool value) { + + allows_uninitialized_input_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.allows_uninitialized_input) +} + +inline const OpDef* OpDef::internal_default_instance() { + return &OpDef_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int OpDeprecation::kVersionFieldNumber; +const int OpDeprecation::kExplanationFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +OpDeprecation::OpDeprecation() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_op_5fdef_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.OpDeprecation) +} +OpDeprecation::OpDeprecation(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_op_5fdef_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.OpDeprecation) +} + +void OpDeprecation::InitAsDefaultInstance() { +} + +OpDeprecation::OpDeprecation(const OpDeprecation& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.OpDeprecation) +} + +void OpDeprecation::SharedCtor() { + explanation_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + version_ = 0; + _cached_size_ = 0; +} + +OpDeprecation::~OpDeprecation() { + // @@protoc_insertion_point(destructor:tensorflow.OpDeprecation) + SharedDtor(); +} + +void OpDeprecation::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + explanation_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); +} + +void OpDeprecation::ArenaDtor(void* object) { + OpDeprecation* _this = reinterpret_cast< OpDeprecation* >(object); + (void)_this; +} +void OpDeprecation::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void OpDeprecation::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OpDeprecation::descriptor() { + protobuf_AssignDescriptorsOnce(); + return OpDeprecation_descriptor_; +} + +const OpDeprecation& OpDeprecation::default_instance() { + protobuf_InitDefaults_op_5fdef_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed OpDeprecation_default_instance_; + +OpDeprecation* OpDeprecation::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void OpDeprecation::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.OpDeprecation) + version_ = 0; + explanation_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} + +bool OpDeprecation::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.OpDeprecation) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 version = 1; + case 1: { + if (tag == 8) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &version_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_explanation; + break; + } + + // optional string explanation = 2; + case 2: { + if (tag == 18) { + parse_explanation: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_explanation())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->explanation().data(), this->explanation().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.OpDeprecation.explanation")); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.OpDeprecation) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.OpDeprecation) + return false; +#undef DO_ +} + +void OpDeprecation::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.OpDeprecation) + // optional int32 version = 1; + if (this->version() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->version(), output); + } + + // optional string explanation = 2; + if (this->explanation().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->explanation().data(), this->explanation().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDeprecation.explanation"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->explanation(), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.OpDeprecation) +} + +::google::protobuf::uint8* OpDeprecation::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.OpDeprecation) + // optional int32 version = 1; + if (this->version() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->version(), target); + } + + // optional string explanation = 2; + if (this->explanation().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->explanation().data(), this->explanation().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.OpDeprecation.explanation"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->explanation(), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.OpDeprecation) + return target; +} + +size_t OpDeprecation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.OpDeprecation) + size_t total_size = 0; + + // optional int32 version = 1; + if (this->version() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->version()); + } + + // optional string explanation = 2; + if (this->explanation().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->explanation()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OpDeprecation::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.OpDeprecation) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const OpDeprecation* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.OpDeprecation) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.OpDeprecation) + UnsafeMergeFrom(*source); + } +} + +void OpDeprecation::MergeFrom(const OpDeprecation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.OpDeprecation) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void OpDeprecation::UnsafeMergeFrom(const OpDeprecation& from) { + GOOGLE_DCHECK(&from != this); + if (from.version() != 0) { + set_version(from.version()); + } + if (from.explanation().size() > 0) { + set_explanation(from.explanation()); + } +} + +void OpDeprecation::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.OpDeprecation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OpDeprecation::CopyFrom(const OpDeprecation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.OpDeprecation) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool OpDeprecation::IsInitialized() const { + + return true; +} + +void OpDeprecation::Swap(OpDeprecation* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + OpDeprecation temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void OpDeprecation::UnsafeArenaSwap(OpDeprecation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void OpDeprecation::InternalSwap(OpDeprecation* other) { + std::swap(version_, other->version_); + explanation_.Swap(&other->explanation_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata OpDeprecation::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = OpDeprecation_descriptor_; + metadata.reflection = OpDeprecation_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// OpDeprecation + +// optional int32 version = 1; +void OpDeprecation::clear_version() { + version_ = 0; +} +::google::protobuf::int32 OpDeprecation::version() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.version) + return version_; +} +void OpDeprecation::set_version(::google::protobuf::int32 value) { + + version_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.version) +} + +// optional string explanation = 2; +void OpDeprecation::clear_explanation() { + explanation_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& OpDeprecation::explanation() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.explanation) + return explanation_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void OpDeprecation::set_explanation(const ::std::string& value) { + + explanation_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.explanation) +} +void OpDeprecation::set_explanation(const char* value) { + + explanation_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDeprecation.explanation) +} +void OpDeprecation::set_explanation(const char* value, + size_t size) { + + explanation_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDeprecation.explanation) +} +::std::string* OpDeprecation::mutable_explanation() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDeprecation.explanation) + return explanation_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDeprecation::release_explanation() { + // @@protoc_insertion_point(field_release:tensorflow.OpDeprecation.explanation) + + return explanation_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* OpDeprecation::unsafe_arena_release_explanation() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDeprecation.explanation) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return explanation_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void OpDeprecation::set_allocated_explanation(::std::string* explanation) { + if (explanation != NULL) { + + } else { + + } + explanation_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), explanation, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDeprecation.explanation) +} +void OpDeprecation::unsafe_arena_set_allocated_explanation( + ::std::string* explanation) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (explanation != NULL) { + + } else { + + } + explanation_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + explanation, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDeprecation.explanation) +} + +inline const OpDeprecation* OpDeprecation::internal_default_instance() { + return &OpDeprecation_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int OpList::kOpFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +OpList::OpList() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_op_5fdef_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.OpList) +} +OpList::OpList(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + op_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_op_5fdef_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.OpList) +} + +void OpList::InitAsDefaultInstance() { +} + +OpList::OpList(const OpList& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.OpList) +} + +void OpList::SharedCtor() { + _cached_size_ = 0; +} + +OpList::~OpList() { + // @@protoc_insertion_point(destructor:tensorflow.OpList) + SharedDtor(); +} + +void OpList::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + +} + +void OpList::ArenaDtor(void* object) { + OpList* _this = reinterpret_cast< OpList* >(object); + (void)_this; +} +void OpList::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void OpList::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OpList::descriptor() { + protobuf_AssignDescriptorsOnce(); + return OpList_descriptor_; +} + +const OpList& OpList::default_instance() { + protobuf_InitDefaults_op_5fdef_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed OpList_default_instance_; + +OpList* OpList::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void OpList::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.OpList) + op_.Clear(); +} + +bool OpList::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.OpList) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .tensorflow.OpDef op = 1; + case 1: { + if (tag == 10) { + DO_(input->IncrementRecursionDepth()); + parse_loop_op: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_op())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_loop_op; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.OpList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.OpList) + return false; +#undef DO_ +} + +void OpList::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.OpList) + // repeated .tensorflow.OpDef op = 1; + for (unsigned int i = 0, n = this->op_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->op(i), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.OpList) +} + +::google::protobuf::uint8* OpList::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.OpList) + // repeated .tensorflow.OpDef op = 1; + for (unsigned int i = 0, n = this->op_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 1, this->op(i), false, target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.OpList) + return target; +} + +size_t OpList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.OpList) + size_t total_size = 0; + + // repeated .tensorflow.OpDef op = 1; + { + unsigned int count = this->op_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->op(i)); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OpList::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.OpList) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const OpList* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.OpList) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.OpList) + UnsafeMergeFrom(*source); + } +} + +void OpList::MergeFrom(const OpList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.OpList) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void OpList::UnsafeMergeFrom(const OpList& from) { + GOOGLE_DCHECK(&from != this); + op_.MergeFrom(from.op_); +} + +void OpList::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.OpList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OpList::CopyFrom(const OpList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.OpList) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool OpList::IsInitialized() const { + + return true; +} + +void OpList::Swap(OpList* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + OpList temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void OpList::UnsafeArenaSwap(OpList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void OpList::InternalSwap(OpList* other) { + op_.UnsafeArenaSwap(&other->op_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata OpList::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = OpList_descriptor_; + metadata.reflection = OpList_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// OpList + +// repeated .tensorflow.OpDef op = 1; +int OpList::op_size() const { + return op_.size(); +} +void OpList::clear_op() { + op_.Clear(); +} +const ::tensorflow::OpDef& OpList::op(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpList.op) + return op_.Get(index); +} +::tensorflow::OpDef* OpList::mutable_op(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpList.op) + return op_.Mutable(index); +} +::tensorflow::OpDef* OpList::add_op() { + // @@protoc_insertion_point(field_add:tensorflow.OpList.op) + return op_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef >* +OpList::mutable_op() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpList.op) + return &op_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef >& +OpList::op() const { + // @@protoc_insertion_point(field_list:tensorflow.OpList.op) + return op_; +} + +inline const OpList* OpList::internal_default_instance() { + return &OpList_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/op_def.pb.h b/modules/dnn/misc/tensorflow/op_def.pb.h new file mode 100644 index 0000000000..71956e4d20 --- /dev/null +++ b/modules/dnn/misc/tensorflow/op_def.pb.h @@ -0,0 +1,2103 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: op_def.proto + +#ifndef PROTOBUF_op_5fdef_2eproto__INCLUDED +#define PROTOBUF_op_5fdef_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include "attr_value.pb.h" +#include "types.pb.h" +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_op_5fdef_2eproto(); +void protobuf_InitDefaults_op_5fdef_2eproto(); +void protobuf_AssignDesc_op_5fdef_2eproto(); +void protobuf_ShutdownFile_op_5fdef_2eproto(); + +class OpDef; +class OpDef_ArgDef; +class OpDef_AttrDef; +class OpDeprecation; +class OpList; + +// =================================================================== + +class OpDef_ArgDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDef.ArgDef) */ { + public: + OpDef_ArgDef(); + virtual ~OpDef_ArgDef(); + + OpDef_ArgDef(const OpDef_ArgDef& from); + + inline OpDef_ArgDef& operator=(const OpDef_ArgDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const OpDef_ArgDef& default_instance(); + + static const OpDef_ArgDef* internal_default_instance(); + + void UnsafeArenaSwap(OpDef_ArgDef* other); + void Swap(OpDef_ArgDef* other); + + // implements Message ---------------------------------------------- + + inline OpDef_ArgDef* New() const { return New(NULL); } + + OpDef_ArgDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const OpDef_ArgDef& from); + void MergeFrom(const OpDef_ArgDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(OpDef_ArgDef* other); + void UnsafeMergeFrom(const OpDef_ArgDef& from); + protected: + explicit OpDef_ArgDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string name = 1; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + ::std::string* unsafe_arena_release_name(); + void unsafe_arena_set_allocated_name( + ::std::string* name); + + // optional string description = 2; + void clear_description(); + static const int kDescriptionFieldNumber = 2; + const ::std::string& description() const; + void set_description(const ::std::string& value); + void set_description(const char* value); + void set_description(const char* value, size_t size); + ::std::string* mutable_description(); + ::std::string* release_description(); + void set_allocated_description(::std::string* description); + ::std::string* unsafe_arena_release_description(); + void unsafe_arena_set_allocated_description( + ::std::string* description); + + // optional .tensorflow.DataType type = 3; + void clear_type(); + static const int kTypeFieldNumber = 3; + ::tensorflow::DataType type() const; + void set_type(::tensorflow::DataType value); + + // optional string type_attr = 4; + void clear_type_attr(); + static const int kTypeAttrFieldNumber = 4; + const ::std::string& type_attr() const; + void set_type_attr(const ::std::string& value); + void set_type_attr(const char* value); + void set_type_attr(const char* value, size_t size); + ::std::string* mutable_type_attr(); + ::std::string* release_type_attr(); + void set_allocated_type_attr(::std::string* type_attr); + ::std::string* unsafe_arena_release_type_attr(); + void unsafe_arena_set_allocated_type_attr( + ::std::string* type_attr); + + // optional string number_attr = 5; + void clear_number_attr(); + static const int kNumberAttrFieldNumber = 5; + const ::std::string& number_attr() const; + void set_number_attr(const ::std::string& value); + void set_number_attr(const char* value); + void set_number_attr(const char* value, size_t size); + ::std::string* mutable_number_attr(); + ::std::string* release_number_attr(); + void set_allocated_number_attr(::std::string* number_attr); + ::std::string* unsafe_arena_release_number_attr(); + void unsafe_arena_set_allocated_number_attr( + ::std::string* number_attr); + + // optional string type_list_attr = 6; + void clear_type_list_attr(); + static const int kTypeListAttrFieldNumber = 6; + const ::std::string& type_list_attr() const; + void set_type_list_attr(const ::std::string& value); + void set_type_list_attr(const char* value); + void set_type_list_attr(const char* value, size_t size); + ::std::string* mutable_type_list_attr(); + ::std::string* release_type_list_attr(); + void set_allocated_type_list_attr(::std::string* type_list_attr); + ::std::string* unsafe_arena_release_type_list_attr(); + void unsafe_arena_set_allocated_type_list_attr( + ::std::string* type_list_attr); + + // optional bool is_ref = 16; + void clear_is_ref(); + static const int kIsRefFieldNumber = 16; + bool is_ref() const; + void set_is_ref(bool value); + + // @@protoc_insertion_point(class_scope:tensorflow.OpDef.ArgDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr description_; + ::google::protobuf::internal::ArenaStringPtr type_attr_; + ::google::protobuf::internal::ArenaStringPtr number_attr_; + ::google::protobuf::internal::ArenaStringPtr type_list_attr_; + int type_; + bool is_ref_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_op_5fdef_2eproto_impl(); + friend void protobuf_AddDesc_op_5fdef_2eproto_impl(); + friend void protobuf_AssignDesc_op_5fdef_2eproto(); + friend void protobuf_ShutdownFile_op_5fdef_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed OpDef_ArgDef_default_instance_; + +// ------------------------------------------------------------------- + +class OpDef_AttrDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDef.AttrDef) */ { + public: + OpDef_AttrDef(); + virtual ~OpDef_AttrDef(); + + OpDef_AttrDef(const OpDef_AttrDef& from); + + inline OpDef_AttrDef& operator=(const OpDef_AttrDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const OpDef_AttrDef& default_instance(); + + static const OpDef_AttrDef* internal_default_instance(); + + void UnsafeArenaSwap(OpDef_AttrDef* other); + void Swap(OpDef_AttrDef* other); + + // implements Message ---------------------------------------------- + + inline OpDef_AttrDef* New() const { return New(NULL); } + + OpDef_AttrDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const OpDef_AttrDef& from); + void MergeFrom(const OpDef_AttrDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(OpDef_AttrDef* other); + void UnsafeMergeFrom(const OpDef_AttrDef& from); + protected: + explicit OpDef_AttrDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string name = 1; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + ::std::string* unsafe_arena_release_name(); + void unsafe_arena_set_allocated_name( + ::std::string* name); + + // optional string type = 2; + void clear_type(); + static const int kTypeFieldNumber = 2; + const ::std::string& type() const; + void set_type(const ::std::string& value); + void set_type(const char* value); + void set_type(const char* value, size_t size); + ::std::string* mutable_type(); + ::std::string* release_type(); + void set_allocated_type(::std::string* type); + ::std::string* unsafe_arena_release_type(); + void unsafe_arena_set_allocated_type( + ::std::string* type); + + // optional .tensorflow.AttrValue default_value = 3; + bool has_default_value() const; + void clear_default_value(); + static const int kDefaultValueFieldNumber = 3; + private: + void _slow_mutable_default_value(); + void _slow_set_allocated_default_value( + ::google::protobuf::Arena* message_arena, ::tensorflow::AttrValue** default_value); + ::tensorflow::AttrValue* _slow_release_default_value(); + public: + const ::tensorflow::AttrValue& default_value() const; + ::tensorflow::AttrValue* mutable_default_value(); + ::tensorflow::AttrValue* release_default_value(); + void set_allocated_default_value(::tensorflow::AttrValue* default_value); + ::tensorflow::AttrValue* unsafe_arena_release_default_value(); + void unsafe_arena_set_allocated_default_value( + ::tensorflow::AttrValue* default_value); + + // optional string description = 4; + void clear_description(); + static const int kDescriptionFieldNumber = 4; + const ::std::string& description() const; + void set_description(const ::std::string& value); + void set_description(const char* value); + void set_description(const char* value, size_t size); + ::std::string* mutable_description(); + ::std::string* release_description(); + void set_allocated_description(::std::string* description); + ::std::string* unsafe_arena_release_description(); + void unsafe_arena_set_allocated_description( + ::std::string* description); + + // optional bool has_minimum = 5; + void clear_has_minimum(); + static const int kHasMinimumFieldNumber = 5; + bool has_minimum() const; + void set_has_minimum(bool value); + + // optional int64 minimum = 6; + void clear_minimum(); + static const int kMinimumFieldNumber = 6; + ::google::protobuf::int64 minimum() const; + void set_minimum(::google::protobuf::int64 value); + + // optional .tensorflow.AttrValue allowed_values = 7; + bool has_allowed_values() const; + void clear_allowed_values(); + static const int kAllowedValuesFieldNumber = 7; + private: + void _slow_mutable_allowed_values(); + void _slow_set_allocated_allowed_values( + ::google::protobuf::Arena* message_arena, ::tensorflow::AttrValue** allowed_values); + ::tensorflow::AttrValue* _slow_release_allowed_values(); + public: + const ::tensorflow::AttrValue& allowed_values() const; + ::tensorflow::AttrValue* mutable_allowed_values(); + ::tensorflow::AttrValue* release_allowed_values(); + void set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values); + ::tensorflow::AttrValue* unsafe_arena_release_allowed_values(); + void unsafe_arena_set_allocated_allowed_values( + ::tensorflow::AttrValue* allowed_values); + + // @@protoc_insertion_point(class_scope:tensorflow.OpDef.AttrDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::google::protobuf::internal::ArenaStringPtr description_; + ::tensorflow::AttrValue* default_value_; + ::tensorflow::AttrValue* allowed_values_; + ::google::protobuf::int64 minimum_; + bool has_minimum_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_op_5fdef_2eproto_impl(); + friend void protobuf_AddDesc_op_5fdef_2eproto_impl(); + friend void protobuf_AssignDesc_op_5fdef_2eproto(); + friend void protobuf_ShutdownFile_op_5fdef_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed OpDef_AttrDef_default_instance_; + +// ------------------------------------------------------------------- + +class OpDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDef) */ { + public: + OpDef(); + virtual ~OpDef(); + + OpDef(const OpDef& from); + + inline OpDef& operator=(const OpDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const OpDef& default_instance(); + + static const OpDef* internal_default_instance(); + + void UnsafeArenaSwap(OpDef* other); + void Swap(OpDef* other); + + // implements Message ---------------------------------------------- + + inline OpDef* New() const { return New(NULL); } + + OpDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const OpDef& from); + void MergeFrom(const OpDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(OpDef* other); + void UnsafeMergeFrom(const OpDef& from); + protected: + explicit OpDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef OpDef_ArgDef ArgDef; + typedef OpDef_AttrDef AttrDef; + + // accessors ------------------------------------------------------- + + // optional string name = 1; + void clear_name(); + static const int kNameFieldNumber = 1; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + ::std::string* unsafe_arena_release_name(); + void unsafe_arena_set_allocated_name( + ::std::string* name); + + // repeated .tensorflow.OpDef.ArgDef input_arg = 2; + int input_arg_size() const; + void clear_input_arg(); + static const int kInputArgFieldNumber = 2; + const ::tensorflow::OpDef_ArgDef& input_arg(int index) const; + ::tensorflow::OpDef_ArgDef* mutable_input_arg(int index); + ::tensorflow::OpDef_ArgDef* add_input_arg(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >* + mutable_input_arg(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >& + input_arg() const; + + // repeated .tensorflow.OpDef.ArgDef output_arg = 3; + int output_arg_size() const; + void clear_output_arg(); + static const int kOutputArgFieldNumber = 3; + const ::tensorflow::OpDef_ArgDef& output_arg(int index) const; + ::tensorflow::OpDef_ArgDef* mutable_output_arg(int index); + ::tensorflow::OpDef_ArgDef* add_output_arg(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >* + mutable_output_arg(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >& + output_arg() const; + + // repeated .tensorflow.OpDef.AttrDef attr = 4; + int attr_size() const; + void clear_attr(); + static const int kAttrFieldNumber = 4; + const ::tensorflow::OpDef_AttrDef& attr(int index) const; + ::tensorflow::OpDef_AttrDef* mutable_attr(int index); + ::tensorflow::OpDef_AttrDef* add_attr(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >* + mutable_attr(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >& + attr() const; + + // optional .tensorflow.OpDeprecation deprecation = 8; + bool has_deprecation() const; + void clear_deprecation(); + static const int kDeprecationFieldNumber = 8; + private: + void _slow_mutable_deprecation(); + void _slow_set_allocated_deprecation( + ::google::protobuf::Arena* message_arena, ::tensorflow::OpDeprecation** deprecation); + ::tensorflow::OpDeprecation* _slow_release_deprecation(); + public: + const ::tensorflow::OpDeprecation& deprecation() const; + ::tensorflow::OpDeprecation* mutable_deprecation(); + ::tensorflow::OpDeprecation* release_deprecation(); + void set_allocated_deprecation(::tensorflow::OpDeprecation* deprecation); + ::tensorflow::OpDeprecation* unsafe_arena_release_deprecation(); + void unsafe_arena_set_allocated_deprecation( + ::tensorflow::OpDeprecation* deprecation); + + // optional string summary = 5; + void clear_summary(); + static const int kSummaryFieldNumber = 5; + const ::std::string& summary() const; + void set_summary(const ::std::string& value); + void set_summary(const char* value); + void set_summary(const char* value, size_t size); + ::std::string* mutable_summary(); + ::std::string* release_summary(); + void set_allocated_summary(::std::string* summary); + ::std::string* unsafe_arena_release_summary(); + void unsafe_arena_set_allocated_summary( + ::std::string* summary); + + // optional string description = 6; + void clear_description(); + static const int kDescriptionFieldNumber = 6; + const ::std::string& description() const; + void set_description(const ::std::string& value); + void set_description(const char* value); + void set_description(const char* value, size_t size); + ::std::string* mutable_description(); + ::std::string* release_description(); + void set_allocated_description(::std::string* description); + ::std::string* unsafe_arena_release_description(); + void unsafe_arena_set_allocated_description( + ::std::string* description); + + // optional bool is_commutative = 18; + void clear_is_commutative(); + static const int kIsCommutativeFieldNumber = 18; + bool is_commutative() const; + void set_is_commutative(bool value); + + // optional bool is_aggregate = 16; + void clear_is_aggregate(); + static const int kIsAggregateFieldNumber = 16; + bool is_aggregate() const; + void set_is_aggregate(bool value); + + // optional bool is_stateful = 17; + void clear_is_stateful(); + static const int kIsStatefulFieldNumber = 17; + bool is_stateful() const; + void set_is_stateful(bool value); + + // optional bool allows_uninitialized_input = 19; + void clear_allows_uninitialized_input(); + static const int kAllowsUninitializedInputFieldNumber = 19; + bool allows_uninitialized_input() const; + void set_allows_uninitialized_input(bool value); + + // @@protoc_insertion_point(class_scope:tensorflow.OpDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef > input_arg_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef > output_arg_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_AttrDef > attr_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr summary_; + ::google::protobuf::internal::ArenaStringPtr description_; + ::tensorflow::OpDeprecation* deprecation_; + bool is_commutative_; + bool is_aggregate_; + bool is_stateful_; + bool allows_uninitialized_input_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_op_5fdef_2eproto_impl(); + friend void protobuf_AddDesc_op_5fdef_2eproto_impl(); + friend void protobuf_AssignDesc_op_5fdef_2eproto(); + friend void protobuf_ShutdownFile_op_5fdef_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed OpDef_default_instance_; + +// ------------------------------------------------------------------- + +class OpDeprecation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDeprecation) */ { + public: + OpDeprecation(); + virtual ~OpDeprecation(); + + OpDeprecation(const OpDeprecation& from); + + inline OpDeprecation& operator=(const OpDeprecation& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const OpDeprecation& default_instance(); + + static const OpDeprecation* internal_default_instance(); + + void UnsafeArenaSwap(OpDeprecation* other); + void Swap(OpDeprecation* other); + + // implements Message ---------------------------------------------- + + inline OpDeprecation* New() const { return New(NULL); } + + OpDeprecation* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const OpDeprecation& from); + void MergeFrom(const OpDeprecation& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(OpDeprecation* other); + void UnsafeMergeFrom(const OpDeprecation& from); + protected: + explicit OpDeprecation(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 version = 1; + void clear_version(); + static const int kVersionFieldNumber = 1; + ::google::protobuf::int32 version() const; + void set_version(::google::protobuf::int32 value); + + // optional string explanation = 2; + void clear_explanation(); + static const int kExplanationFieldNumber = 2; + const ::std::string& explanation() const; + void set_explanation(const ::std::string& value); + void set_explanation(const char* value); + void set_explanation(const char* value, size_t size); + ::std::string* mutable_explanation(); + ::std::string* release_explanation(); + void set_allocated_explanation(::std::string* explanation); + ::std::string* unsafe_arena_release_explanation(); + void unsafe_arena_set_allocated_explanation( + ::std::string* explanation); + + // @@protoc_insertion_point(class_scope:tensorflow.OpDeprecation) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::internal::ArenaStringPtr explanation_; + ::google::protobuf::int32 version_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_op_5fdef_2eproto_impl(); + friend void protobuf_AddDesc_op_5fdef_2eproto_impl(); + friend void protobuf_AssignDesc_op_5fdef_2eproto(); + friend void protobuf_ShutdownFile_op_5fdef_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed OpDeprecation_default_instance_; + +// ------------------------------------------------------------------- + +class OpList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpList) */ { + public: + OpList(); + virtual ~OpList(); + + OpList(const OpList& from); + + inline OpList& operator=(const OpList& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const OpList& default_instance(); + + static const OpList* internal_default_instance(); + + void UnsafeArenaSwap(OpList* other); + void Swap(OpList* other); + + // implements Message ---------------------------------------------- + + inline OpList* New() const { return New(NULL); } + + OpList* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const OpList& from); + void MergeFrom(const OpList& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(OpList* other); + void UnsafeMergeFrom(const OpList& from); + protected: + explicit OpList(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .tensorflow.OpDef op = 1; + int op_size() const; + void clear_op(); + static const int kOpFieldNumber = 1; + const ::tensorflow::OpDef& op(int index) const; + ::tensorflow::OpDef* mutable_op(int index); + ::tensorflow::OpDef* add_op(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef >* + mutable_op(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef >& + op() const; + + // @@protoc_insertion_point(class_scope:tensorflow.OpList) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef > op_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_op_5fdef_2eproto_impl(); + friend void protobuf_AddDesc_op_5fdef_2eproto_impl(); + friend void protobuf_AssignDesc_op_5fdef_2eproto(); + friend void protobuf_ShutdownFile_op_5fdef_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed OpList_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// OpDef_ArgDef + +// optional string name = 1; +inline void OpDef_ArgDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_ArgDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_ArgDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.name) +} +inline void OpDef_ArgDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.name) +} +inline void OpDef_ArgDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.name) +} +inline ::std::string* OpDef_ArgDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_ArgDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.name) +} +inline void OpDef_ArgDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.name) +} + +// optional string description = 2; +inline void OpDef_ArgDef::clear_description() { + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_ArgDef::description() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.description) + return description_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_ArgDef::set_description(const ::std::string& value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.description) +} +inline void OpDef_ArgDef::set_description(const char* value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.description) +} +inline void OpDef_ArgDef::set_description(const char* value, + size_t size) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.description) +} +inline ::std::string* OpDef_ArgDef::mutable_description() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.description) + return description_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::release_description() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.description) + + return description_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.description) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return description_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_ArgDef::set_allocated_description(::std::string* description) { + if (description != NULL) { + + } else { + + } + description_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.description) +} +inline void OpDef_ArgDef::unsafe_arena_set_allocated_description( + ::std::string* description) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (description != NULL) { + + } else { + + } + description_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + description, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.description) +} + +// optional .tensorflow.DataType type = 3; +inline void OpDef_ArgDef::clear_type() { + type_ = 0; +} +inline ::tensorflow::DataType OpDef_ArgDef::type() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type) + return static_cast< ::tensorflow::DataType >(type_); +} +inline void OpDef_ArgDef::set_type(::tensorflow::DataType value) { + + type_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type) +} + +// optional string type_attr = 4; +inline void OpDef_ArgDef::clear_type_attr() { + type_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_ArgDef::type_attr() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_attr) + return type_attr_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_ArgDef::set_type_attr(const ::std::string& value) { + + type_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_attr) +} +inline void OpDef_ArgDef::set_type_attr(const char* value) { + + type_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.type_attr) +} +inline void OpDef_ArgDef::set_type_attr(const char* value, + size_t size) { + + type_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.type_attr) +} +inline ::std::string* OpDef_ArgDef::mutable_type_attr() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_attr) + return type_attr_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::release_type_attr() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_attr) + + return type_attr_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::unsafe_arena_release_type_attr() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.type_attr) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return type_attr_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_ArgDef::set_allocated_type_attr(::std::string* type_attr) { + if (type_attr != NULL) { + + } else { + + } + type_attr_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_attr, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_attr) +} +inline void OpDef_ArgDef::unsafe_arena_set_allocated_type_attr( + ::std::string* type_attr) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (type_attr != NULL) { + + } else { + + } + type_attr_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + type_attr, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.type_attr) +} + +// optional string number_attr = 5; +inline void OpDef_ArgDef::clear_number_attr() { + number_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_ArgDef::number_attr() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.number_attr) + return number_attr_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_ArgDef::set_number_attr(const ::std::string& value) { + + number_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.number_attr) +} +inline void OpDef_ArgDef::set_number_attr(const char* value) { + + number_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.number_attr) +} +inline void OpDef_ArgDef::set_number_attr(const char* value, + size_t size) { + + number_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.number_attr) +} +inline ::std::string* OpDef_ArgDef::mutable_number_attr() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.number_attr) + return number_attr_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::release_number_attr() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.number_attr) + + return number_attr_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::unsafe_arena_release_number_attr() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.number_attr) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return number_attr_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_ArgDef::set_allocated_number_attr(::std::string* number_attr) { + if (number_attr != NULL) { + + } else { + + } + number_attr_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), number_attr, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.number_attr) +} +inline void OpDef_ArgDef::unsafe_arena_set_allocated_number_attr( + ::std::string* number_attr) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (number_attr != NULL) { + + } else { + + } + number_attr_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + number_attr, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.number_attr) +} + +// optional string type_list_attr = 6; +inline void OpDef_ArgDef::clear_type_list_attr() { + type_list_attr_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_ArgDef::type_list_attr() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_list_attr) + return type_list_attr_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_ArgDef::set_type_list_attr(const ::std::string& value) { + + type_list_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_list_attr) +} +inline void OpDef_ArgDef::set_type_list_attr(const char* value) { + + type_list_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.ArgDef.type_list_attr) +} +inline void OpDef_ArgDef::set_type_list_attr(const char* value, + size_t size) { + + type_list_attr_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.ArgDef.type_list_attr) +} +inline ::std::string* OpDef_ArgDef::mutable_type_list_attr() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_list_attr) + return type_list_attr_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::release_type_list_attr() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_list_attr) + + return type_list_attr_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_ArgDef::unsafe_arena_release_type_list_attr() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.ArgDef.type_list_attr) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return type_list_attr_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_ArgDef::set_allocated_type_list_attr(::std::string* type_list_attr) { + if (type_list_attr != NULL) { + + } else { + + } + type_list_attr_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_list_attr, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_list_attr) +} +inline void OpDef_ArgDef::unsafe_arena_set_allocated_type_list_attr( + ::std::string* type_list_attr) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (type_list_attr != NULL) { + + } else { + + } + type_list_attr_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + type_list_attr, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.type_list_attr) +} + +// optional bool is_ref = 16; +inline void OpDef_ArgDef::clear_is_ref() { + is_ref_ = false; +} +inline bool OpDef_ArgDef::is_ref() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.is_ref) + return is_ref_; +} +inline void OpDef_ArgDef::set_is_ref(bool value) { + + is_ref_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.is_ref) +} + +inline const OpDef_ArgDef* OpDef_ArgDef::internal_default_instance() { + return &OpDef_ArgDef_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// OpDef_AttrDef + +// optional string name = 1; +inline void OpDef_AttrDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_AttrDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_AttrDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.name) +} +inline void OpDef_AttrDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.AttrDef.name) +} +inline void OpDef_AttrDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.AttrDef.name) +} +inline ::std::string* OpDef_AttrDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_AttrDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_AttrDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_AttrDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.name) +} +inline void OpDef_AttrDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.name) +} + +// optional string type = 2; +inline void OpDef_AttrDef::clear_type() { + type_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_AttrDef::type() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.type) + return type_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_AttrDef::set_type(const ::std::string& value) { + + type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.type) +} +inline void OpDef_AttrDef::set_type(const char* value) { + + type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.AttrDef.type) +} +inline void OpDef_AttrDef::set_type(const char* value, + size_t size) { + + type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.AttrDef.type) +} +inline ::std::string* OpDef_AttrDef::mutable_type() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.type) + return type_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_AttrDef::release_type() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.type) + + return type_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_AttrDef::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.type) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return type_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_AttrDef::set_allocated_type(::std::string* type) { + if (type != NULL) { + + } else { + + } + type_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.type) +} +inline void OpDef_AttrDef::unsafe_arena_set_allocated_type( + ::std::string* type) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (type != NULL) { + + } else { + + } + type_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + type, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.type) +} + +// optional .tensorflow.AttrValue default_value = 3; +inline bool OpDef_AttrDef::has_default_value() const { + return this != internal_default_instance() && default_value_ != NULL; +} +inline void OpDef_AttrDef::clear_default_value() { + if (GetArenaNoVirtual() == NULL && default_value_ != NULL) delete default_value_; + default_value_ = NULL; +} +inline const ::tensorflow::AttrValue& OpDef_AttrDef::default_value() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.default_value) + return default_value_ != NULL ? *default_value_ + : *::tensorflow::AttrValue::internal_default_instance(); +} +inline ::tensorflow::AttrValue* OpDef_AttrDef::mutable_default_value() { + + if (default_value_ == NULL) { + _slow_mutable_default_value(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.default_value) + return default_value_; +} +inline ::tensorflow::AttrValue* OpDef_AttrDef::release_default_value() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.default_value) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_default_value(); + } else { + ::tensorflow::AttrValue* temp = default_value_; + default_value_ = NULL; + return temp; + } +} +inline void OpDef_AttrDef::set_allocated_default_value(::tensorflow::AttrValue* default_value) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete default_value_; + } + if (default_value != NULL) { + _slow_set_allocated_default_value(message_arena, &default_value); + } + default_value_ = default_value; + if (default_value) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.default_value) +} + +// optional string description = 4; +inline void OpDef_AttrDef::clear_description() { + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef_AttrDef::description() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.description) + return description_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef_AttrDef::set_description(const ::std::string& value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.description) +} +inline void OpDef_AttrDef::set_description(const char* value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.AttrDef.description) +} +inline void OpDef_AttrDef::set_description(const char* value, + size_t size) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.AttrDef.description) +} +inline ::std::string* OpDef_AttrDef::mutable_description() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.description) + return description_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_AttrDef::release_description() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.description) + + return description_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef_AttrDef::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.AttrDef.description) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return description_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef_AttrDef::set_allocated_description(::std::string* description) { + if (description != NULL) { + + } else { + + } + description_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.description) +} +inline void OpDef_AttrDef::unsafe_arena_set_allocated_description( + ::std::string* description) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (description != NULL) { + + } else { + + } + description_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + description, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.description) +} + +// optional bool has_minimum = 5; +inline void OpDef_AttrDef::clear_has_minimum() { + has_minimum_ = false; +} +inline bool OpDef_AttrDef::has_minimum() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.has_minimum) + return has_minimum_; +} +inline void OpDef_AttrDef::set_has_minimum(bool value) { + + has_minimum_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.has_minimum) +} + +// optional int64 minimum = 6; +inline void OpDef_AttrDef::clear_minimum() { + minimum_ = GOOGLE_LONGLONG(0); +} +inline ::google::protobuf::int64 OpDef_AttrDef::minimum() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.minimum) + return minimum_; +} +inline void OpDef_AttrDef::set_minimum(::google::protobuf::int64 value) { + + minimum_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.minimum) +} + +// optional .tensorflow.AttrValue allowed_values = 7; +inline bool OpDef_AttrDef::has_allowed_values() const { + return this != internal_default_instance() && allowed_values_ != NULL; +} +inline void OpDef_AttrDef::clear_allowed_values() { + if (GetArenaNoVirtual() == NULL && allowed_values_ != NULL) delete allowed_values_; + allowed_values_ = NULL; +} +inline const ::tensorflow::AttrValue& OpDef_AttrDef::allowed_values() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.allowed_values) + return allowed_values_ != NULL ? *allowed_values_ + : *::tensorflow::AttrValue::internal_default_instance(); +} +inline ::tensorflow::AttrValue* OpDef_AttrDef::mutable_allowed_values() { + + if (allowed_values_ == NULL) { + _slow_mutable_allowed_values(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.allowed_values) + return allowed_values_; +} +inline ::tensorflow::AttrValue* OpDef_AttrDef::release_allowed_values() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.allowed_values) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_allowed_values(); + } else { + ::tensorflow::AttrValue* temp = allowed_values_; + allowed_values_ = NULL; + return temp; + } +} +inline void OpDef_AttrDef::set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete allowed_values_; + } + if (allowed_values != NULL) { + _slow_set_allocated_allowed_values(message_arena, &allowed_values); + } + allowed_values_ = allowed_values; + if (allowed_values) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.allowed_values) +} + +inline const OpDef_AttrDef* OpDef_AttrDef::internal_default_instance() { + return &OpDef_AttrDef_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// OpDef + +// optional string name = 1; +inline void OpDef::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef::name() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.name) +} +inline void OpDef::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.name) +} +inline void OpDef::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.name) +} +inline ::std::string* OpDef::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.name) +} +inline void OpDef::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.name) +} + +// repeated .tensorflow.OpDef.ArgDef input_arg = 2; +inline int OpDef::input_arg_size() const { + return input_arg_.size(); +} +inline void OpDef::clear_input_arg() { + input_arg_.Clear(); +} +inline const ::tensorflow::OpDef_ArgDef& OpDef::input_arg(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.input_arg) + return input_arg_.Get(index); +} +inline ::tensorflow::OpDef_ArgDef* OpDef::mutable_input_arg(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.input_arg) + return input_arg_.Mutable(index); +} +inline ::tensorflow::OpDef_ArgDef* OpDef::add_input_arg() { + // @@protoc_insertion_point(field_add:tensorflow.OpDef.input_arg) + return input_arg_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >* +OpDef::mutable_input_arg() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.input_arg) + return &input_arg_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >& +OpDef::input_arg() const { + // @@protoc_insertion_point(field_list:tensorflow.OpDef.input_arg) + return input_arg_; +} + +// repeated .tensorflow.OpDef.ArgDef output_arg = 3; +inline int OpDef::output_arg_size() const { + return output_arg_.size(); +} +inline void OpDef::clear_output_arg() { + output_arg_.Clear(); +} +inline const ::tensorflow::OpDef_ArgDef& OpDef::output_arg(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.output_arg) + return output_arg_.Get(index); +} +inline ::tensorflow::OpDef_ArgDef* OpDef::mutable_output_arg(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.output_arg) + return output_arg_.Mutable(index); +} +inline ::tensorflow::OpDef_ArgDef* OpDef::add_output_arg() { + // @@protoc_insertion_point(field_add:tensorflow.OpDef.output_arg) + return output_arg_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >* +OpDef::mutable_output_arg() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.output_arg) + return &output_arg_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >& +OpDef::output_arg() const { + // @@protoc_insertion_point(field_list:tensorflow.OpDef.output_arg) + return output_arg_; +} + +// repeated .tensorflow.OpDef.AttrDef attr = 4; +inline int OpDef::attr_size() const { + return attr_.size(); +} +inline void OpDef::clear_attr() { + attr_.Clear(); +} +inline const ::tensorflow::OpDef_AttrDef& OpDef::attr(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.attr) + return attr_.Get(index); +} +inline ::tensorflow::OpDef_AttrDef* OpDef::mutable_attr(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.attr) + return attr_.Mutable(index); +} +inline ::tensorflow::OpDef_AttrDef* OpDef::add_attr() { + // @@protoc_insertion_point(field_add:tensorflow.OpDef.attr) + return attr_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >* +OpDef::mutable_attr() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.attr) + return &attr_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >& +OpDef::attr() const { + // @@protoc_insertion_point(field_list:tensorflow.OpDef.attr) + return attr_; +} + +// optional .tensorflow.OpDeprecation deprecation = 8; +inline bool OpDef::has_deprecation() const { + return this != internal_default_instance() && deprecation_ != NULL; +} +inline void OpDef::clear_deprecation() { + if (GetArenaNoVirtual() == NULL && deprecation_ != NULL) delete deprecation_; + deprecation_ = NULL; +} +inline const ::tensorflow::OpDeprecation& OpDef::deprecation() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.deprecation) + return deprecation_ != NULL ? *deprecation_ + : *::tensorflow::OpDeprecation::internal_default_instance(); +} +inline ::tensorflow::OpDeprecation* OpDef::mutable_deprecation() { + + if (deprecation_ == NULL) { + _slow_mutable_deprecation(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.deprecation) + return deprecation_; +} +inline ::tensorflow::OpDeprecation* OpDef::release_deprecation() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.deprecation) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_deprecation(); + } else { + ::tensorflow::OpDeprecation* temp = deprecation_; + deprecation_ = NULL; + return temp; + } +} +inline void OpDef::set_allocated_deprecation(::tensorflow::OpDeprecation* deprecation) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete deprecation_; + } + if (deprecation != NULL) { + _slow_set_allocated_deprecation(message_arena, &deprecation); + } + deprecation_ = deprecation; + if (deprecation) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.deprecation) +} + +// optional string summary = 5; +inline void OpDef::clear_summary() { + summary_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef::summary() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.summary) + return summary_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef::set_summary(const ::std::string& value) { + + summary_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.summary) +} +inline void OpDef::set_summary(const char* value) { + + summary_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.summary) +} +inline void OpDef::set_summary(const char* value, + size_t size) { + + summary_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.summary) +} +inline ::std::string* OpDef::mutable_summary() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.summary) + return summary_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef::release_summary() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.summary) + + return summary_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef::unsafe_arena_release_summary() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.summary) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return summary_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef::set_allocated_summary(::std::string* summary) { + if (summary != NULL) { + + } else { + + } + summary_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), summary, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.summary) +} +inline void OpDef::unsafe_arena_set_allocated_summary( + ::std::string* summary) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (summary != NULL) { + + } else { + + } + summary_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + summary, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.summary) +} + +// optional string description = 6; +inline void OpDef::clear_description() { + description_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDef::description() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.description) + return description_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDef::set_description(const ::std::string& value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDef.description) +} +inline void OpDef::set_description(const char* value) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.description) +} +inline void OpDef::set_description(const char* value, + size_t size) { + + description_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.description) +} +inline ::std::string* OpDef::mutable_description() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.description) + return description_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef::release_description() { + // @@protoc_insertion_point(field_release:tensorflow.OpDef.description) + + return description_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDef::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDef.description) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return description_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDef::set_allocated_description(::std::string* description) { + if (description != NULL) { + + } else { + + } + description_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.description) +} +inline void OpDef::unsafe_arena_set_allocated_description( + ::std::string* description) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (description != NULL) { + + } else { + + } + description_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + description, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.description) +} + +// optional bool is_commutative = 18; +inline void OpDef::clear_is_commutative() { + is_commutative_ = false; +} +inline bool OpDef::is_commutative() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_commutative) + return is_commutative_; +} +inline void OpDef::set_is_commutative(bool value) { + + is_commutative_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_commutative) +} + +// optional bool is_aggregate = 16; +inline void OpDef::clear_is_aggregate() { + is_aggregate_ = false; +} +inline bool OpDef::is_aggregate() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_aggregate) + return is_aggregate_; +} +inline void OpDef::set_is_aggregate(bool value) { + + is_aggregate_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_aggregate) +} + +// optional bool is_stateful = 17; +inline void OpDef::clear_is_stateful() { + is_stateful_ = false; +} +inline bool OpDef::is_stateful() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_stateful) + return is_stateful_; +} +inline void OpDef::set_is_stateful(bool value) { + + is_stateful_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_stateful) +} + +// optional bool allows_uninitialized_input = 19; +inline void OpDef::clear_allows_uninitialized_input() { + allows_uninitialized_input_ = false; +} +inline bool OpDef::allows_uninitialized_input() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDef.allows_uninitialized_input) + return allows_uninitialized_input_; +} +inline void OpDef::set_allows_uninitialized_input(bool value) { + + allows_uninitialized_input_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDef.allows_uninitialized_input) +} + +inline const OpDef* OpDef::internal_default_instance() { + return &OpDef_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// OpDeprecation + +// optional int32 version = 1; +inline void OpDeprecation::clear_version() { + version_ = 0; +} +inline ::google::protobuf::int32 OpDeprecation::version() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.version) + return version_; +} +inline void OpDeprecation::set_version(::google::protobuf::int32 value) { + + version_ = value; + // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.version) +} + +// optional string explanation = 2; +inline void OpDeprecation::clear_explanation() { + explanation_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& OpDeprecation::explanation() const { + // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.explanation) + return explanation_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void OpDeprecation::set_explanation(const ::std::string& value) { + + explanation_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.explanation) +} +inline void OpDeprecation::set_explanation(const char* value) { + + explanation_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.OpDeprecation.explanation) +} +inline void OpDeprecation::set_explanation(const char* value, + size_t size) { + + explanation_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDeprecation.explanation) +} +inline ::std::string* OpDeprecation::mutable_explanation() { + + // @@protoc_insertion_point(field_mutable:tensorflow.OpDeprecation.explanation) + return explanation_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDeprecation::release_explanation() { + // @@protoc_insertion_point(field_release:tensorflow.OpDeprecation.explanation) + + return explanation_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* OpDeprecation::unsafe_arena_release_explanation() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpDeprecation.explanation) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return explanation_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void OpDeprecation::set_allocated_explanation(::std::string* explanation) { + if (explanation != NULL) { + + } else { + + } + explanation_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), explanation, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDeprecation.explanation) +} +inline void OpDeprecation::unsafe_arena_set_allocated_explanation( + ::std::string* explanation) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (explanation != NULL) { + + } else { + + } + explanation_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + explanation, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDeprecation.explanation) +} + +inline const OpDeprecation* OpDeprecation::internal_default_instance() { + return &OpDeprecation_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// OpList + +// repeated .tensorflow.OpDef op = 1; +inline int OpList::op_size() const { + return op_.size(); +} +inline void OpList::clear_op() { + op_.Clear(); +} +inline const ::tensorflow::OpDef& OpList::op(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.OpList.op) + return op_.Get(index); +} +inline ::tensorflow::OpDef* OpList::mutable_op(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.OpList.op) + return op_.Mutable(index); +} +inline ::tensorflow::OpDef* OpList::add_op() { + // @@protoc_insertion_point(field_add:tensorflow.OpList.op) + return op_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef >* +OpList::mutable_op() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.OpList.op) + return &op_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::OpDef >& +OpList::op() const { + // @@protoc_insertion_point(field_list:tensorflow.OpList.op) + return op_; +} + +inline const OpList* OpList::internal_default_instance() { + return &OpList_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_op_5fdef_2eproto__INCLUDED diff --git a/modules/dnn/misc/tensorflow/tensor.pb.cc b/modules/dnn/misc/tensorflow/tensor.pb.cc new file mode 100644 index 0000000000..e9851095be --- /dev/null +++ b/modules/dnn/misc/tensorflow/tensor.pb.cc @@ -0,0 +1,1596 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: tensor.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "tensor.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::Descriptor* TensorProto_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TensorProto_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_tensor_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_tensor_2eproto() { + protobuf_AddDesc_tensor_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "tensor.proto"); + GOOGLE_CHECK(file != NULL); + TensorProto_descriptor_ = file->message_type(0); + static const int TensorProto_offsets_[13] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, dtype_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, tensor_shape_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, version_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, tensor_content_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, half_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, float_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, double_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, int_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, string_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, scomplex_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, int64_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, bool_val_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, dcomplex_val_), + }; + TensorProto_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + TensorProto_descriptor_, + TensorProto::internal_default_instance(), + TensorProto_offsets_, + -1, + -1, + -1, + sizeof(TensorProto), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, _internal_metadata_)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_tensor_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TensorProto_descriptor_, TensorProto::internal_default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_tensor_2eproto() { + TensorProto_default_instance_.Shutdown(); + delete TensorProto_reflection_; +} + +void protobuf_InitDefaults_tensor_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::tensorflow::protobuf_InitDefaults_tensor_5fshape_2eproto(); + ::tensorflow::protobuf_InitDefaults_types_2eproto(); + ::google::protobuf::internal::GetEmptyString(); + TensorProto_default_instance_.DefaultConstruct(); + TensorProto_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_tensor_2eproto_once_); +void protobuf_InitDefaults_tensor_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_tensor_2eproto_once_, + &protobuf_InitDefaults_tensor_2eproto_impl); +} +void protobuf_AddDesc_tensor_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_tensor_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\014tensor.proto\022\ntensorflow\032\022tensor_shape" + ".proto\032\013types.proto\"\345\002\n\013TensorProto\022#\n\005d" + "type\030\001 \001(\0162\024.tensorflow.DataType\0222\n\014tens" + "or_shape\030\002 \001(\0132\034.tensorflow.TensorShapeP" + "roto\022\026\n\016version_number\030\003 \001(\005\022\026\n\016tensor_c" + "ontent\030\004 \001(\014\022\024\n\010half_val\030\r \003(\005B\002\020\001\022\025\n\tfl" + "oat_val\030\005 \003(\002B\002\020\001\022\026\n\ndouble_val\030\006 \003(\001B\002\020" + "\001\022\023\n\007int_val\030\007 \003(\005B\002\020\001\022\022\n\nstring_val\030\010 \003" + "(\014\022\030\n\014scomplex_val\030\t \003(\002B\002\020\001\022\025\n\tint64_va" + "l\030\n \003(\003B\002\020\001\022\024\n\010bool_val\030\013 \003(\010B\002\020\001\022\030\n\014dco" + "mplex_val\030\014 \003(\001B\002\020\001B-\n\030org.tensorflow.fr" + "ameworkB\014TensorProtosP\001\370\001\001b\006proto3", 474); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "tensor.proto", &protobuf_RegisterTypes); + ::tensorflow::protobuf_AddDesc_tensor_5fshape_2eproto(); + ::tensorflow::protobuf_AddDesc_types_2eproto(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_tensor_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_tensor_2eproto_once_); +void protobuf_AddDesc_tensor_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_tensor_2eproto_once_, + &protobuf_AddDesc_tensor_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_tensor_2eproto { + StaticDescriptorInitializer_tensor_2eproto() { + protobuf_AddDesc_tensor_2eproto(); + } +} static_descriptor_initializer_tensor_2eproto_; + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +void TensorProto::_slow_mutable_tensor_shape() { + tensor_shape_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >( + GetArenaNoVirtual()); +} +::tensorflow::TensorShapeProto* TensorProto::_slow_release_tensor_shape() { + if (tensor_shape_ == NULL) { + return NULL; + } else { + ::tensorflow::TensorShapeProto* temp = new ::tensorflow::TensorShapeProto(*tensor_shape_); + tensor_shape_ = NULL; + return temp; + } +} +::tensorflow::TensorShapeProto* TensorProto::unsafe_arena_release_tensor_shape() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorProto.tensor_shape) + + ::tensorflow::TensorShapeProto* temp = tensor_shape_; + tensor_shape_ = NULL; + return temp; +} +void TensorProto::_slow_set_allocated_tensor_shape( + ::google::protobuf::Arena* message_arena, ::tensorflow::TensorShapeProto** tensor_shape) { + if (message_arena != NULL && + ::google::protobuf::Arena::GetArena(*tensor_shape) == NULL) { + message_arena->Own(*tensor_shape); + } else if (message_arena != + ::google::protobuf::Arena::GetArena(*tensor_shape)) { + ::tensorflow::TensorShapeProto* new_tensor_shape = + ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >( + message_arena); + new_tensor_shape->CopyFrom(**tensor_shape); + *tensor_shape = new_tensor_shape; + } +} +void TensorProto::unsafe_arena_set_allocated_tensor_shape( + ::tensorflow::TensorShapeProto* tensor_shape) { + if (GetArenaNoVirtual() == NULL) { + delete tensor_shape_; + } + tensor_shape_ = tensor_shape; + if (tensor_shape) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorProto.tensor_shape) +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TensorProto::kDtypeFieldNumber; +const int TensorProto::kTensorShapeFieldNumber; +const int TensorProto::kVersionNumberFieldNumber; +const int TensorProto::kTensorContentFieldNumber; +const int TensorProto::kHalfValFieldNumber; +const int TensorProto::kFloatValFieldNumber; +const int TensorProto::kDoubleValFieldNumber; +const int TensorProto::kIntValFieldNumber; +const int TensorProto::kStringValFieldNumber; +const int TensorProto::kScomplexValFieldNumber; +const int TensorProto::kInt64ValFieldNumber; +const int TensorProto::kBoolValFieldNumber; +const int TensorProto::kDcomplexValFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TensorProto::TensorProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_tensor_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.TensorProto) +} +TensorProto::TensorProto(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + half_val_(arena), + float_val_(arena), + double_val_(arena), + int_val_(arena), + string_val_(arena), + scomplex_val_(arena), + int64_val_(arena), + bool_val_(arena), + dcomplex_val_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_tensor_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.TensorProto) +} + +void TensorProto::InitAsDefaultInstance() { + tensor_shape_ = const_cast< ::tensorflow::TensorShapeProto*>( + ::tensorflow::TensorShapeProto::internal_default_instance()); +} + +TensorProto::TensorProto(const TensorProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.TensorProto) +} + +void TensorProto::SharedCtor() { + tensor_content_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + tensor_shape_ = NULL; + ::memset(&dtype_, 0, reinterpret_cast(&version_number_) - + reinterpret_cast(&dtype_) + sizeof(version_number_)); + _cached_size_ = 0; +} + +TensorProto::~TensorProto() { + // @@protoc_insertion_point(destructor:tensorflow.TensorProto) + SharedDtor(); +} + +void TensorProto::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + tensor_content_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); + if (this != &TensorProto_default_instance_.get()) { + delete tensor_shape_; + } +} + +void TensorProto::ArenaDtor(void* object) { + TensorProto* _this = reinterpret_cast< TensorProto* >(object); + (void)_this; +} +void TensorProto::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void TensorProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TensorProto::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TensorProto_descriptor_; +} + +const TensorProto& TensorProto::default_instance() { + protobuf_InitDefaults_tensor_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed TensorProto_default_instance_; + +TensorProto* TensorProto::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void TensorProto::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.TensorProto) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(TensorProto, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(dtype_, version_number_); + if (GetArenaNoVirtual() == NULL && tensor_shape_ != NULL) delete tensor_shape_; + tensor_shape_ = NULL; + tensor_content_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + +#undef ZR_HELPER_ +#undef ZR_ + + half_val_.Clear(); + float_val_.Clear(); + double_val_.Clear(); + int_val_.Clear(); + string_val_.Clear(); + scomplex_val_.Clear(); + int64_val_.Clear(); + bool_val_.Clear(); + dcomplex_val_.Clear(); +} + +bool TensorProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.TensorProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .tensorflow.DataType dtype = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_dtype(static_cast< ::tensorflow::DataType >(value)); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_tensor_shape; + break; + } + + // optional .tensorflow.TensorShapeProto tensor_shape = 2; + case 2: { + if (tag == 18) { + parse_tensor_shape: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tensor_shape())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_version_number; + break; + } + + // optional int32 version_number = 3; + case 3: { + if (tag == 24) { + parse_version_number: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &version_number_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_tensor_content; + break; + } + + // optional bytes tensor_content = 4; + case 4: { + if (tag == 34) { + parse_tensor_content: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_tensor_content())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_float_val; + break; + } + + // repeated float float_val = 5 [packed = true]; + case 5: { + if (tag == 42) { + parse_float_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_float_val()))); + } else if (tag == 45) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 42, input, this->mutable_float_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_double_val; + break; + } + + // repeated double double_val = 6 [packed = true]; + case 6: { + if (tag == 50) { + parse_double_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_val()))); + } else if (tag == 49) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 50, input, this->mutable_double_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_int_val; + break; + } + + // repeated int32 int_val = 7 [packed = true]; + case 7: { + if (tag == 58) { + parse_int_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_int_val()))); + } else if (tag == 56) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 58, input, this->mutable_int_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_string_val; + break; + } + + // repeated bytes string_val = 8; + case 8: { + if (tag == 66) { + parse_string_val: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->add_string_val())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_string_val; + if (input->ExpectTag(74)) goto parse_scomplex_val; + break; + } + + // repeated float scomplex_val = 9 [packed = true]; + case 9: { + if (tag == 74) { + parse_scomplex_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_scomplex_val()))); + } else if (tag == 77) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 74, input, this->mutable_scomplex_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_int64_val; + break; + } + + // repeated int64 int64_val = 10 [packed = true]; + case 10: { + if (tag == 82) { + parse_int64_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int64_val()))); + } else if (tag == 80) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + 1, 82, input, this->mutable_int64_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(90)) goto parse_bool_val; + break; + } + + // repeated bool bool_val = 11 [packed = true]; + case 11: { + if (tag == 90) { + parse_bool_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, this->mutable_bool_val()))); + } else if (tag == 88) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + 1, 90, input, this->mutable_bool_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(98)) goto parse_dcomplex_val; + break; + } + + // repeated double dcomplex_val = 12 [packed = true]; + case 12: { + if (tag == 98) { + parse_dcomplex_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_dcomplex_val()))); + } else if (tag == 97) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 98, input, this->mutable_dcomplex_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(106)) goto parse_half_val; + break; + } + + // repeated int32 half_val = 13 [packed = true]; + case 13: { + if (tag == 106) { + parse_half_val: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_half_val()))); + } else if (tag == 104) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 106, input, this->mutable_half_val()))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.TensorProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.TensorProto) + return false; +#undef DO_ +} + +void TensorProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.TensorProto) + // optional .tensorflow.DataType dtype = 1; + if (this->dtype() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->dtype(), output); + } + + // optional .tensorflow.TensorShapeProto tensor_shape = 2; + if (this->has_tensor_shape()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *this->tensor_shape_, output); + } + + // optional int32 version_number = 3; + if (this->version_number() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->version_number(), output); + } + + // optional bytes tensor_content = 4; + if (this->tensor_content().size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 4, this->tensor_content(), output); + } + + // repeated float float_val = 5 [packed = true]; + if (this->float_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_float_val_cached_byte_size_); + } + for (int i = 0; i < this->float_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloatNoTag( + this->float_val(i), output); + } + + // repeated double double_val = 6 [packed = true]; + if (this->double_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_val_cached_byte_size_); + } + for (int i = 0; i < this->double_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteDoubleNoTag( + this->double_val(i), output); + } + + // repeated int32 int_val = 7 [packed = true]; + if (this->int_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int_val_cached_byte_size_); + } + for (int i = 0; i < this->int_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag( + this->int_val(i), output); + } + + // repeated bytes string_val = 8; + for (int i = 0; i < this->string_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 8, this->string_val(i), output); + } + + // repeated float scomplex_val = 9 [packed = true]; + if (this->scomplex_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_scomplex_val_cached_byte_size_); + } + for (int i = 0; i < this->scomplex_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloatNoTag( + this->scomplex_val(i), output); + } + + // repeated int64 int64_val = 10 [packed = true]; + if (this->int64_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(10, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int64_val_cached_byte_size_); + } + for (int i = 0; i < this->int64_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt64NoTag( + this->int64_val(i), output); + } + + // repeated bool bool_val = 11 [packed = true]; + if (this->bool_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(11, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_bool_val_cached_byte_size_); + } + for (int i = 0; i < this->bool_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteBoolNoTag( + this->bool_val(i), output); + } + + // repeated double dcomplex_val = 12 [packed = true]; + if (this->dcomplex_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(12, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_dcomplex_val_cached_byte_size_); + } + for (int i = 0; i < this->dcomplex_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteDoubleNoTag( + this->dcomplex_val(i), output); + } + + // repeated int32 half_val = 13 [packed = true]; + if (this->half_val_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(13, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_half_val_cached_byte_size_); + } + for (int i = 0; i < this->half_val_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag( + this->half_val(i), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.TensorProto) +} + +::google::protobuf::uint8* TensorProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TensorProto) + // optional .tensorflow.DataType dtype = 1; + if (this->dtype() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->dtype(), target); + } + + // optional .tensorflow.TensorShapeProto tensor_shape = 2; + if (this->has_tensor_shape()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, *this->tensor_shape_, false, target); + } + + // optional int32 version_number = 3; + if (this->version_number() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->version_number(), target); + } + + // optional bytes tensor_content = 4; + if (this->tensor_content().size() > 0) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 4, this->tensor_content(), target); + } + + // repeated float float_val = 5 [packed = true]; + if (this->float_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 5, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _float_val_cached_byte_size_, target); + } + for (int i = 0; i < this->float_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->float_val(i), target); + } + + // repeated double double_val = 6 [packed = true]; + if (this->double_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 6, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _double_val_cached_byte_size_, target); + } + for (int i = 0; i < this->double_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_val(i), target); + } + + // repeated int32 int_val = 7 [packed = true]; + if (this->int_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 7, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _int_val_cached_byte_size_, target); + } + for (int i = 0; i < this->int_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32NoTagToArray(this->int_val(i), target); + } + + // repeated bytes string_val = 8; + for (int i = 0; i < this->string_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBytesToArray(8, this->string_val(i), target); + } + + // repeated float scomplex_val = 9 [packed = true]; + if (this->scomplex_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 9, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _scomplex_val_cached_byte_size_, target); + } + for (int i = 0; i < this->scomplex_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->scomplex_val(i), target); + } + + // repeated int64 int64_val = 10 [packed = true]; + if (this->int64_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 10, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _int64_val_cached_byte_size_, target); + } + for (int i = 0; i < this->int64_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int64_val(i), target); + } + + // repeated bool bool_val = 11 [packed = true]; + if (this->bool_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 11, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _bool_val_cached_byte_size_, target); + } + for (int i = 0; i < this->bool_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBoolNoTagToArray(this->bool_val(i), target); + } + + // repeated double dcomplex_val = 12 [packed = true]; + if (this->dcomplex_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 12, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _dcomplex_val_cached_byte_size_, target); + } + for (int i = 0; i < this->dcomplex_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->dcomplex_val(i), target); + } + + // repeated int32 half_val = 13 [packed = true]; + if (this->half_val_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 13, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _half_val_cached_byte_size_, target); + } + for (int i = 0; i < this->half_val_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32NoTagToArray(this->half_val(i), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TensorProto) + return target; +} + +size_t TensorProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.TensorProto) + size_t total_size = 0; + + // optional .tensorflow.DataType dtype = 1; + if (this->dtype() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->dtype()); + } + + // optional .tensorflow.TensorShapeProto tensor_shape = 2; + if (this->has_tensor_shape()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + *this->tensor_shape_); + } + + // optional int32 version_number = 3; + if (this->version_number() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->version_number()); + } + + // optional bytes tensor_content = 4; + if (this->tensor_content().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->tensor_content()); + } + + // repeated int32 half_val = 13 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->half_val_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->half_val(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _half_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated float float_val = 5 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->float_val_size(); + data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _float_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated double double_val = 6 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->double_val_size(); + data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _double_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated int32 int_val = 7 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->int_val_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->int_val(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _int_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated bytes string_val = 8; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->string_val_size()); + for (int i = 0; i < this->string_val_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( + this->string_val(i)); + } + + // repeated float scomplex_val = 9 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->scomplex_val_size(); + data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _scomplex_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated int64 int64_val = 10 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->int64_val_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int64Size(this->int64_val(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _int64_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated bool bool_val = 11 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->bool_val_size(); + data_size = 1UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _bool_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated double dcomplex_val = 12 [packed = true]; + { + size_t data_size = 0; + unsigned int count = this->dcomplex_val_size(); + data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _dcomplex_val_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TensorProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.TensorProto) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const TensorProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.TensorProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.TensorProto) + UnsafeMergeFrom(*source); + } +} + +void TensorProto::MergeFrom(const TensorProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TensorProto) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void TensorProto::UnsafeMergeFrom(const TensorProto& from) { + GOOGLE_DCHECK(&from != this); + half_val_.UnsafeMergeFrom(from.half_val_); + float_val_.UnsafeMergeFrom(from.float_val_); + double_val_.UnsafeMergeFrom(from.double_val_); + int_val_.UnsafeMergeFrom(from.int_val_); + string_val_.UnsafeMergeFrom(from.string_val_); + scomplex_val_.UnsafeMergeFrom(from.scomplex_val_); + int64_val_.UnsafeMergeFrom(from.int64_val_); + bool_val_.UnsafeMergeFrom(from.bool_val_); + dcomplex_val_.UnsafeMergeFrom(from.dcomplex_val_); + if (from.dtype() != 0) { + set_dtype(from.dtype()); + } + if (from.has_tensor_shape()) { + mutable_tensor_shape()->::tensorflow::TensorShapeProto::MergeFrom(from.tensor_shape()); + } + if (from.version_number() != 0) { + set_version_number(from.version_number()); + } + if (from.tensor_content().size() > 0) { + set_tensor_content(from.tensor_content()); + } +} + +void TensorProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.TensorProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TensorProto::CopyFrom(const TensorProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TensorProto) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool TensorProto::IsInitialized() const { + + return true; +} + +void TensorProto::Swap(TensorProto* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + TensorProto temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void TensorProto::UnsafeArenaSwap(TensorProto* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void TensorProto::InternalSwap(TensorProto* other) { + std::swap(dtype_, other->dtype_); + std::swap(tensor_shape_, other->tensor_shape_); + std::swap(version_number_, other->version_number_); + tensor_content_.Swap(&other->tensor_content_); + half_val_.UnsafeArenaSwap(&other->half_val_); + float_val_.UnsafeArenaSwap(&other->float_val_); + double_val_.UnsafeArenaSwap(&other->double_val_); + int_val_.UnsafeArenaSwap(&other->int_val_); + string_val_.UnsafeArenaSwap(&other->string_val_); + scomplex_val_.UnsafeArenaSwap(&other->scomplex_val_); + int64_val_.UnsafeArenaSwap(&other->int64_val_); + bool_val_.UnsafeArenaSwap(&other->bool_val_); + dcomplex_val_.UnsafeArenaSwap(&other->dcomplex_val_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TensorProto::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TensorProto_descriptor_; + metadata.reflection = TensorProto_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// TensorProto + +// optional .tensorflow.DataType dtype = 1; +void TensorProto::clear_dtype() { + dtype_ = 0; +} +::tensorflow::DataType TensorProto::dtype() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.dtype) + return static_cast< ::tensorflow::DataType >(dtype_); +} +void TensorProto::set_dtype(::tensorflow::DataType value) { + + dtype_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.dtype) +} + +// optional .tensorflow.TensorShapeProto tensor_shape = 2; +bool TensorProto::has_tensor_shape() const { + return this != internal_default_instance() && tensor_shape_ != NULL; +} +void TensorProto::clear_tensor_shape() { + if (GetArenaNoVirtual() == NULL && tensor_shape_ != NULL) delete tensor_shape_; + tensor_shape_ = NULL; +} +const ::tensorflow::TensorShapeProto& TensorProto::tensor_shape() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_shape) + return tensor_shape_ != NULL ? *tensor_shape_ + : *::tensorflow::TensorShapeProto::internal_default_instance(); +} +::tensorflow::TensorShapeProto* TensorProto::mutable_tensor_shape() { + + if (tensor_shape_ == NULL) { + _slow_mutable_tensor_shape(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_shape) + return tensor_shape_; +} +::tensorflow::TensorShapeProto* TensorProto::release_tensor_shape() { + // @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_shape) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_tensor_shape(); + } else { + ::tensorflow::TensorShapeProto* temp = tensor_shape_; + tensor_shape_ = NULL; + return temp; + } +} + void TensorProto::set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete tensor_shape_; + } + if (tensor_shape != NULL) { + _slow_set_allocated_tensor_shape(message_arena, &tensor_shape); + } + tensor_shape_ = tensor_shape; + if (tensor_shape) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_shape) +} + +// optional int32 version_number = 3; +void TensorProto::clear_version_number() { + version_number_ = 0; +} +::google::protobuf::int32 TensorProto::version_number() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.version_number) + return version_number_; +} +void TensorProto::set_version_number(::google::protobuf::int32 value) { + + version_number_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.version_number) +} + +// optional bytes tensor_content = 4; +void TensorProto::clear_tensor_content() { + tensor_content_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& TensorProto::tensor_content() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_content) + return tensor_content_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void TensorProto::set_tensor_content(const ::std::string& value) { + + tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.tensor_content) +} +void TensorProto::set_tensor_content(const char* value) { + + tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.tensor_content) +} +void TensorProto::set_tensor_content(const void* value, + size_t size) { + + tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.tensor_content) +} +::std::string* TensorProto::mutable_tensor_content() { + + // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_content) + return tensor_content_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* TensorProto::release_tensor_content() { + // @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_content) + + return tensor_content_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* TensorProto::unsafe_arena_release_tensor_content() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorProto.tensor_content) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return tensor_content_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void TensorProto::set_allocated_tensor_content(::std::string* tensor_content) { + if (tensor_content != NULL) { + + } else { + + } + tensor_content_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), tensor_content, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_content) +} +void TensorProto::unsafe_arena_set_allocated_tensor_content( + ::std::string* tensor_content) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (tensor_content != NULL) { + + } else { + + } + tensor_content_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + tensor_content, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorProto.tensor_content) +} + +// repeated int32 half_val = 13 [packed = true]; +int TensorProto::half_val_size() const { + return half_val_.size(); +} +void TensorProto::clear_half_val() { + half_val_.Clear(); +} +::google::protobuf::int32 TensorProto::half_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.half_val) + return half_val_.Get(index); +} +void TensorProto::set_half_val(int index, ::google::protobuf::int32 value) { + half_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.half_val) +} +void TensorProto::add_half_val(::google::protobuf::int32 value) { + half_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.half_val) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +TensorProto::half_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.half_val) + return half_val_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +TensorProto::mutable_half_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.half_val) + return &half_val_; +} + +// repeated float float_val = 5 [packed = true]; +int TensorProto::float_val_size() const { + return float_val_.size(); +} +void TensorProto::clear_float_val() { + float_val_.Clear(); +} +float TensorProto::float_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.float_val) + return float_val_.Get(index); +} +void TensorProto::set_float_val(int index, float value) { + float_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.float_val) +} +void TensorProto::add_float_val(float value) { + float_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.float_val) +} +const ::google::protobuf::RepeatedField< float >& +TensorProto::float_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.float_val) + return float_val_; +} +::google::protobuf::RepeatedField< float >* +TensorProto::mutable_float_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.float_val) + return &float_val_; +} + +// repeated double double_val = 6 [packed = true]; +int TensorProto::double_val_size() const { + return double_val_.size(); +} +void TensorProto::clear_double_val() { + double_val_.Clear(); +} +double TensorProto::double_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.double_val) + return double_val_.Get(index); +} +void TensorProto::set_double_val(int index, double value) { + double_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.double_val) +} +void TensorProto::add_double_val(double value) { + double_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.double_val) +} +const ::google::protobuf::RepeatedField< double >& +TensorProto::double_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.double_val) + return double_val_; +} +::google::protobuf::RepeatedField< double >* +TensorProto::mutable_double_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.double_val) + return &double_val_; +} + +// repeated int32 int_val = 7 [packed = true]; +int TensorProto::int_val_size() const { + return int_val_.size(); +} +void TensorProto::clear_int_val() { + int_val_.Clear(); +} +::google::protobuf::int32 TensorProto::int_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int_val) + return int_val_.Get(index); +} +void TensorProto::set_int_val(int index, ::google::protobuf::int32 value) { + int_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int_val) +} +void TensorProto::add_int_val(::google::protobuf::int32 value) { + int_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int_val) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +TensorProto::int_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int_val) + return int_val_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +TensorProto::mutable_int_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int_val) + return &int_val_; +} + +// repeated bytes string_val = 8; +int TensorProto::string_val_size() const { + return string_val_.size(); +} +void TensorProto::clear_string_val() { + string_val_.Clear(); +} +const ::std::string& TensorProto::string_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.string_val) + return string_val_.Get(index); +} +::std::string* TensorProto::mutable_string_val(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.string_val) + return string_val_.Mutable(index); +} +void TensorProto::set_string_val(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.string_val) + string_val_.Mutable(index)->assign(value); +} +void TensorProto::set_string_val(int index, const char* value) { + string_val_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.string_val) +} +void TensorProto::set_string_val(int index, const void* value, size_t size) { + string_val_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.string_val) +} +::std::string* TensorProto::add_string_val() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.TensorProto.string_val) + return string_val_.Add(); +} +void TensorProto::add_string_val(const ::std::string& value) { + string_val_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.string_val) +} +void TensorProto::add_string_val(const char* value) { + string_val_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.TensorProto.string_val) +} +void TensorProto::add_string_val(const void* value, size_t size) { + string_val_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.TensorProto.string_val) +} +const ::google::protobuf::RepeatedPtrField< ::std::string>& +TensorProto::string_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.string_val) + return string_val_; +} +::google::protobuf::RepeatedPtrField< ::std::string>* +TensorProto::mutable_string_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.string_val) + return &string_val_; +} + +// repeated float scomplex_val = 9 [packed = true]; +int TensorProto::scomplex_val_size() const { + return scomplex_val_.size(); +} +void TensorProto::clear_scomplex_val() { + scomplex_val_.Clear(); +} +float TensorProto::scomplex_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.scomplex_val) + return scomplex_val_.Get(index); +} +void TensorProto::set_scomplex_val(int index, float value) { + scomplex_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.scomplex_val) +} +void TensorProto::add_scomplex_val(float value) { + scomplex_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.scomplex_val) +} +const ::google::protobuf::RepeatedField< float >& +TensorProto::scomplex_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.scomplex_val) + return scomplex_val_; +} +::google::protobuf::RepeatedField< float >* +TensorProto::mutable_scomplex_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.scomplex_val) + return &scomplex_val_; +} + +// repeated int64 int64_val = 10 [packed = true]; +int TensorProto::int64_val_size() const { + return int64_val_.size(); +} +void TensorProto::clear_int64_val() { + int64_val_.Clear(); +} +::google::protobuf::int64 TensorProto::int64_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int64_val) + return int64_val_.Get(index); +} +void TensorProto::set_int64_val(int index, ::google::protobuf::int64 value) { + int64_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int64_val) +} +void TensorProto::add_int64_val(::google::protobuf::int64 value) { + int64_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int64_val) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& +TensorProto::int64_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int64_val) + return int64_val_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int64 >* +TensorProto::mutable_int64_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int64_val) + return &int64_val_; +} + +// repeated bool bool_val = 11 [packed = true]; +int TensorProto::bool_val_size() const { + return bool_val_.size(); +} +void TensorProto::clear_bool_val() { + bool_val_.Clear(); +} +bool TensorProto::bool_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.bool_val) + return bool_val_.Get(index); +} +void TensorProto::set_bool_val(int index, bool value) { + bool_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.bool_val) +} +void TensorProto::add_bool_val(bool value) { + bool_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.bool_val) +} +const ::google::protobuf::RepeatedField< bool >& +TensorProto::bool_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.bool_val) + return bool_val_; +} +::google::protobuf::RepeatedField< bool >* +TensorProto::mutable_bool_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.bool_val) + return &bool_val_; +} + +// repeated double dcomplex_val = 12 [packed = true]; +int TensorProto::dcomplex_val_size() const { + return dcomplex_val_.size(); +} +void TensorProto::clear_dcomplex_val() { + dcomplex_val_.Clear(); +} +double TensorProto::dcomplex_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.dcomplex_val) + return dcomplex_val_.Get(index); +} +void TensorProto::set_dcomplex_val(int index, double value) { + dcomplex_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.dcomplex_val) +} +void TensorProto::add_dcomplex_val(double value) { + dcomplex_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.dcomplex_val) +} +const ::google::protobuf::RepeatedField< double >& +TensorProto::dcomplex_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.dcomplex_val) + return dcomplex_val_; +} +::google::protobuf::RepeatedField< double >* +TensorProto::mutable_dcomplex_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.dcomplex_val) + return &dcomplex_val_; +} + +inline const TensorProto* TensorProto::internal_default_instance() { + return &TensorProto_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/tensor.pb.h b/modules/dnn/misc/tensorflow/tensor.pb.h new file mode 100644 index 0000000000..362821f563 --- /dev/null +++ b/modules/dnn/misc/tensorflow/tensor.pb.h @@ -0,0 +1,770 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: tensor.proto + +#ifndef PROTOBUF_tensor_2eproto__INCLUDED +#define PROTOBUF_tensor_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include "tensor_shape.pb.h" +#include "types.pb.h" +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_tensor_2eproto(); +void protobuf_InitDefaults_tensor_2eproto(); +void protobuf_AssignDesc_tensor_2eproto(); +void protobuf_ShutdownFile_tensor_2eproto(); + +class TensorProto; + +// =================================================================== + +class TensorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorProto) */ { + public: + TensorProto(); + virtual ~TensorProto(); + + TensorProto(const TensorProto& from); + + inline TensorProto& operator=(const TensorProto& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const TensorProto& default_instance(); + + static const TensorProto* internal_default_instance(); + + void UnsafeArenaSwap(TensorProto* other); + void Swap(TensorProto* other); + + // implements Message ---------------------------------------------- + + inline TensorProto* New() const { return New(NULL); } + + TensorProto* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TensorProto& from); + void MergeFrom(const TensorProto& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorProto* other); + void UnsafeMergeFrom(const TensorProto& from); + protected: + explicit TensorProto(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .tensorflow.DataType dtype = 1; + void clear_dtype(); + static const int kDtypeFieldNumber = 1; + ::tensorflow::DataType dtype() const; + void set_dtype(::tensorflow::DataType value); + + // optional .tensorflow.TensorShapeProto tensor_shape = 2; + bool has_tensor_shape() const; + void clear_tensor_shape(); + static const int kTensorShapeFieldNumber = 2; + private: + void _slow_mutable_tensor_shape(); + void _slow_set_allocated_tensor_shape( + ::google::protobuf::Arena* message_arena, ::tensorflow::TensorShapeProto** tensor_shape); + ::tensorflow::TensorShapeProto* _slow_release_tensor_shape(); + public: + const ::tensorflow::TensorShapeProto& tensor_shape() const; + ::tensorflow::TensorShapeProto* mutable_tensor_shape(); + ::tensorflow::TensorShapeProto* release_tensor_shape(); + void set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape); + ::tensorflow::TensorShapeProto* unsafe_arena_release_tensor_shape(); + void unsafe_arena_set_allocated_tensor_shape( + ::tensorflow::TensorShapeProto* tensor_shape); + + // optional int32 version_number = 3; + void clear_version_number(); + static const int kVersionNumberFieldNumber = 3; + ::google::protobuf::int32 version_number() const; + void set_version_number(::google::protobuf::int32 value); + + // optional bytes tensor_content = 4; + void clear_tensor_content(); + static const int kTensorContentFieldNumber = 4; + const ::std::string& tensor_content() const; + void set_tensor_content(const ::std::string& value); + void set_tensor_content(const char* value); + void set_tensor_content(const void* value, size_t size); + ::std::string* mutable_tensor_content(); + ::std::string* release_tensor_content(); + void set_allocated_tensor_content(::std::string* tensor_content); + ::std::string* unsafe_arena_release_tensor_content(); + void unsafe_arena_set_allocated_tensor_content( + ::std::string* tensor_content); + + // repeated int32 half_val = 13 [packed = true]; + int half_val_size() const; + void clear_half_val(); + static const int kHalfValFieldNumber = 13; + ::google::protobuf::int32 half_val(int index) const; + void set_half_val(int index, ::google::protobuf::int32 value); + void add_half_val(::google::protobuf::int32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + half_val() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_half_val(); + + // repeated float float_val = 5 [packed = true]; + int float_val_size() const; + void clear_float_val(); + static const int kFloatValFieldNumber = 5; + float float_val(int index) const; + void set_float_val(int index, float value); + void add_float_val(float value); + const ::google::protobuf::RepeatedField< float >& + float_val() const; + ::google::protobuf::RepeatedField< float >* + mutable_float_val(); + + // repeated double double_val = 6 [packed = true]; + int double_val_size() const; + void clear_double_val(); + static const int kDoubleValFieldNumber = 6; + double double_val(int index) const; + void set_double_val(int index, double value); + void add_double_val(double value); + const ::google::protobuf::RepeatedField< double >& + double_val() const; + ::google::protobuf::RepeatedField< double >* + mutable_double_val(); + + // repeated int32 int_val = 7 [packed = true]; + int int_val_size() const; + void clear_int_val(); + static const int kIntValFieldNumber = 7; + ::google::protobuf::int32 int_val(int index) const; + void set_int_val(int index, ::google::protobuf::int32 value); + void add_int_val(::google::protobuf::int32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + int_val() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_int_val(); + + // repeated bytes string_val = 8; + int string_val_size() const; + void clear_string_val(); + static const int kStringValFieldNumber = 8; + const ::std::string& string_val(int index) const; + ::std::string* mutable_string_val(int index); + void set_string_val(int index, const ::std::string& value); + void set_string_val(int index, const char* value); + void set_string_val(int index, const void* value, size_t size); + ::std::string* add_string_val(); + void add_string_val(const ::std::string& value); + void add_string_val(const char* value); + void add_string_val(const void* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& string_val() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_val(); + + // repeated float scomplex_val = 9 [packed = true]; + int scomplex_val_size() const; + void clear_scomplex_val(); + static const int kScomplexValFieldNumber = 9; + float scomplex_val(int index) const; + void set_scomplex_val(int index, float value); + void add_scomplex_val(float value); + const ::google::protobuf::RepeatedField< float >& + scomplex_val() const; + ::google::protobuf::RepeatedField< float >* + mutable_scomplex_val(); + + // repeated int64 int64_val = 10 [packed = true]; + int int64_val_size() const; + void clear_int64_val(); + static const int kInt64ValFieldNumber = 10; + ::google::protobuf::int64 int64_val(int index) const; + void set_int64_val(int index, ::google::protobuf::int64 value); + void add_int64_val(::google::protobuf::int64 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& + int64_val() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int64 >* + mutable_int64_val(); + + // repeated bool bool_val = 11 [packed = true]; + int bool_val_size() const; + void clear_bool_val(); + static const int kBoolValFieldNumber = 11; + bool bool_val(int index) const; + void set_bool_val(int index, bool value); + void add_bool_val(bool value); + const ::google::protobuf::RepeatedField< bool >& + bool_val() const; + ::google::protobuf::RepeatedField< bool >* + mutable_bool_val(); + + // repeated double dcomplex_val = 12 [packed = true]; + int dcomplex_val_size() const; + void clear_dcomplex_val(); + static const int kDcomplexValFieldNumber = 12; + double dcomplex_val(int index) const; + void set_dcomplex_val(int index, double value); + void add_dcomplex_val(double value); + const ::google::protobuf::RepeatedField< double >& + dcomplex_val() const; + ::google::protobuf::RepeatedField< double >* + mutable_dcomplex_val(); + + // @@protoc_insertion_point(class_scope:tensorflow.TensorProto) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > half_val_; + mutable int _half_val_cached_byte_size_; + ::google::protobuf::RepeatedField< float > float_val_; + mutable int _float_val_cached_byte_size_; + ::google::protobuf::RepeatedField< double > double_val_; + mutable int _double_val_cached_byte_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > int_val_; + mutable int _int_val_cached_byte_size_; + ::google::protobuf::RepeatedPtrField< ::std::string> string_val_; + ::google::protobuf::RepeatedField< float > scomplex_val_; + mutable int _scomplex_val_cached_byte_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::int64 > int64_val_; + mutable int _int64_val_cached_byte_size_; + ::google::protobuf::RepeatedField< bool > bool_val_; + mutable int _bool_val_cached_byte_size_; + ::google::protobuf::RepeatedField< double > dcomplex_val_; + mutable int _dcomplex_val_cached_byte_size_; + ::google::protobuf::internal::ArenaStringPtr tensor_content_; + ::tensorflow::TensorShapeProto* tensor_shape_; + int dtype_; + ::google::protobuf::int32 version_number_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_tensor_2eproto_impl(); + friend void protobuf_AddDesc_tensor_2eproto_impl(); + friend void protobuf_AssignDesc_tensor_2eproto(); + friend void protobuf_ShutdownFile_tensor_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed TensorProto_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// TensorProto + +// optional .tensorflow.DataType dtype = 1; +inline void TensorProto::clear_dtype() { + dtype_ = 0; +} +inline ::tensorflow::DataType TensorProto::dtype() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.dtype) + return static_cast< ::tensorflow::DataType >(dtype_); +} +inline void TensorProto::set_dtype(::tensorflow::DataType value) { + + dtype_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.dtype) +} + +// optional .tensorflow.TensorShapeProto tensor_shape = 2; +inline bool TensorProto::has_tensor_shape() const { + return this != internal_default_instance() && tensor_shape_ != NULL; +} +inline void TensorProto::clear_tensor_shape() { + if (GetArenaNoVirtual() == NULL && tensor_shape_ != NULL) delete tensor_shape_; + tensor_shape_ = NULL; +} +inline const ::tensorflow::TensorShapeProto& TensorProto::tensor_shape() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_shape) + return tensor_shape_ != NULL ? *tensor_shape_ + : *::tensorflow::TensorShapeProto::internal_default_instance(); +} +inline ::tensorflow::TensorShapeProto* TensorProto::mutable_tensor_shape() { + + if (tensor_shape_ == NULL) { + _slow_mutable_tensor_shape(); + } + // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_shape) + return tensor_shape_; +} +inline ::tensorflow::TensorShapeProto* TensorProto::release_tensor_shape() { + // @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_shape) + + if (GetArenaNoVirtual() != NULL) { + return _slow_release_tensor_shape(); + } else { + ::tensorflow::TensorShapeProto* temp = tensor_shape_; + tensor_shape_ = NULL; + return temp; + } +} +inline void TensorProto::set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete tensor_shape_; + } + if (tensor_shape != NULL) { + _slow_set_allocated_tensor_shape(message_arena, &tensor_shape); + } + tensor_shape_ = tensor_shape; + if (tensor_shape) { + + } else { + + } + // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_shape) +} + +// optional int32 version_number = 3; +inline void TensorProto::clear_version_number() { + version_number_ = 0; +} +inline ::google::protobuf::int32 TensorProto::version_number() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.version_number) + return version_number_; +} +inline void TensorProto::set_version_number(::google::protobuf::int32 value) { + + version_number_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.version_number) +} + +// optional bytes tensor_content = 4; +inline void TensorProto::clear_tensor_content() { + tensor_content_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& TensorProto::tensor_content() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_content) + return tensor_content_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void TensorProto::set_tensor_content(const ::std::string& value) { + + tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.tensor_content) +} +inline void TensorProto::set_tensor_content(const char* value) { + + tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.tensor_content) +} +inline void TensorProto::set_tensor_content(const void* value, + size_t size) { + + tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.tensor_content) +} +inline ::std::string* TensorProto::mutable_tensor_content() { + + // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_content) + return tensor_content_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* TensorProto::release_tensor_content() { + // @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_content) + + return tensor_content_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* TensorProto::unsafe_arena_release_tensor_content() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorProto.tensor_content) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return tensor_content_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void TensorProto::set_allocated_tensor_content(::std::string* tensor_content) { + if (tensor_content != NULL) { + + } else { + + } + tensor_content_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), tensor_content, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_content) +} +inline void TensorProto::unsafe_arena_set_allocated_tensor_content( + ::std::string* tensor_content) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (tensor_content != NULL) { + + } else { + + } + tensor_content_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + tensor_content, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorProto.tensor_content) +} + +// repeated int32 half_val = 13 [packed = true]; +inline int TensorProto::half_val_size() const { + return half_val_.size(); +} +inline void TensorProto::clear_half_val() { + half_val_.Clear(); +} +inline ::google::protobuf::int32 TensorProto::half_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.half_val) + return half_val_.Get(index); +} +inline void TensorProto::set_half_val(int index, ::google::protobuf::int32 value) { + half_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.half_val) +} +inline void TensorProto::add_half_val(::google::protobuf::int32 value) { + half_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.half_val) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +TensorProto::half_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.half_val) + return half_val_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +TensorProto::mutable_half_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.half_val) + return &half_val_; +} + +// repeated float float_val = 5 [packed = true]; +inline int TensorProto::float_val_size() const { + return float_val_.size(); +} +inline void TensorProto::clear_float_val() { + float_val_.Clear(); +} +inline float TensorProto::float_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.float_val) + return float_val_.Get(index); +} +inline void TensorProto::set_float_val(int index, float value) { + float_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.float_val) +} +inline void TensorProto::add_float_val(float value) { + float_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.float_val) +} +inline const ::google::protobuf::RepeatedField< float >& +TensorProto::float_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.float_val) + return float_val_; +} +inline ::google::protobuf::RepeatedField< float >* +TensorProto::mutable_float_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.float_val) + return &float_val_; +} + +// repeated double double_val = 6 [packed = true]; +inline int TensorProto::double_val_size() const { + return double_val_.size(); +} +inline void TensorProto::clear_double_val() { + double_val_.Clear(); +} +inline double TensorProto::double_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.double_val) + return double_val_.Get(index); +} +inline void TensorProto::set_double_val(int index, double value) { + double_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.double_val) +} +inline void TensorProto::add_double_val(double value) { + double_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.double_val) +} +inline const ::google::protobuf::RepeatedField< double >& +TensorProto::double_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.double_val) + return double_val_; +} +inline ::google::protobuf::RepeatedField< double >* +TensorProto::mutable_double_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.double_val) + return &double_val_; +} + +// repeated int32 int_val = 7 [packed = true]; +inline int TensorProto::int_val_size() const { + return int_val_.size(); +} +inline void TensorProto::clear_int_val() { + int_val_.Clear(); +} +inline ::google::protobuf::int32 TensorProto::int_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int_val) + return int_val_.Get(index); +} +inline void TensorProto::set_int_val(int index, ::google::protobuf::int32 value) { + int_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int_val) +} +inline void TensorProto::add_int_val(::google::protobuf::int32 value) { + int_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int_val) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +TensorProto::int_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int_val) + return int_val_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +TensorProto::mutable_int_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int_val) + return &int_val_; +} + +// repeated bytes string_val = 8; +inline int TensorProto::string_val_size() const { + return string_val_.size(); +} +inline void TensorProto::clear_string_val() { + string_val_.Clear(); +} +inline const ::std::string& TensorProto::string_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.string_val) + return string_val_.Get(index); +} +inline ::std::string* TensorProto::mutable_string_val(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.string_val) + return string_val_.Mutable(index); +} +inline void TensorProto::set_string_val(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.string_val) + string_val_.Mutable(index)->assign(value); +} +inline void TensorProto::set_string_val(int index, const char* value) { + string_val_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.string_val) +} +inline void TensorProto::set_string_val(int index, const void* value, size_t size) { + string_val_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.string_val) +} +inline ::std::string* TensorProto::add_string_val() { + // @@protoc_insertion_point(field_add_mutable:tensorflow.TensorProto.string_val) + return string_val_.Add(); +} +inline void TensorProto::add_string_val(const ::std::string& value) { + string_val_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.string_val) +} +inline void TensorProto::add_string_val(const char* value) { + string_val_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tensorflow.TensorProto.string_val) +} +inline void TensorProto::add_string_val(const void* value, size_t size) { + string_val_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tensorflow.TensorProto.string_val) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +TensorProto::string_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.string_val) + return string_val_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +TensorProto::mutable_string_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.string_val) + return &string_val_; +} + +// repeated float scomplex_val = 9 [packed = true]; +inline int TensorProto::scomplex_val_size() const { + return scomplex_val_.size(); +} +inline void TensorProto::clear_scomplex_val() { + scomplex_val_.Clear(); +} +inline float TensorProto::scomplex_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.scomplex_val) + return scomplex_val_.Get(index); +} +inline void TensorProto::set_scomplex_val(int index, float value) { + scomplex_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.scomplex_val) +} +inline void TensorProto::add_scomplex_val(float value) { + scomplex_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.scomplex_val) +} +inline const ::google::protobuf::RepeatedField< float >& +TensorProto::scomplex_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.scomplex_val) + return scomplex_val_; +} +inline ::google::protobuf::RepeatedField< float >* +TensorProto::mutable_scomplex_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.scomplex_val) + return &scomplex_val_; +} + +// repeated int64 int64_val = 10 [packed = true]; +inline int TensorProto::int64_val_size() const { + return int64_val_.size(); +} +inline void TensorProto::clear_int64_val() { + int64_val_.Clear(); +} +inline ::google::protobuf::int64 TensorProto::int64_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int64_val) + return int64_val_.Get(index); +} +inline void TensorProto::set_int64_val(int index, ::google::protobuf::int64 value) { + int64_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int64_val) +} +inline void TensorProto::add_int64_val(::google::protobuf::int64 value) { + int64_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int64_val) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >& +TensorProto::int64_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int64_val) + return int64_val_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >* +TensorProto::mutable_int64_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int64_val) + return &int64_val_; +} + +// repeated bool bool_val = 11 [packed = true]; +inline int TensorProto::bool_val_size() const { + return bool_val_.size(); +} +inline void TensorProto::clear_bool_val() { + bool_val_.Clear(); +} +inline bool TensorProto::bool_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.bool_val) + return bool_val_.Get(index); +} +inline void TensorProto::set_bool_val(int index, bool value) { + bool_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.bool_val) +} +inline void TensorProto::add_bool_val(bool value) { + bool_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.bool_val) +} +inline const ::google::protobuf::RepeatedField< bool >& +TensorProto::bool_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.bool_val) + return bool_val_; +} +inline ::google::protobuf::RepeatedField< bool >* +TensorProto::mutable_bool_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.bool_val) + return &bool_val_; +} + +// repeated double dcomplex_val = 12 [packed = true]; +inline int TensorProto::dcomplex_val_size() const { + return dcomplex_val_.size(); +} +inline void TensorProto::clear_dcomplex_val() { + dcomplex_val_.Clear(); +} +inline double TensorProto::dcomplex_val(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorProto.dcomplex_val) + return dcomplex_val_.Get(index); +} +inline void TensorProto::set_dcomplex_val(int index, double value) { + dcomplex_val_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.TensorProto.dcomplex_val) +} +inline void TensorProto::add_dcomplex_val(double value) { + dcomplex_val_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.TensorProto.dcomplex_val) +} +inline const ::google::protobuf::RepeatedField< double >& +TensorProto::dcomplex_val() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorProto.dcomplex_val) + return dcomplex_val_; +} +inline ::google::protobuf::RepeatedField< double >* +TensorProto::mutable_dcomplex_val() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.dcomplex_val) + return &dcomplex_val_; +} + +inline const TensorProto* TensorProto::internal_default_instance() { + return &TensorProto_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_tensor_2eproto__INCLUDED diff --git a/modules/dnn/misc/tensorflow/tensor_shape.pb.cc b/modules/dnn/misc/tensorflow/tensor_shape.pb.cc new file mode 100644 index 0000000000..1e92ff8842 --- /dev/null +++ b/modules/dnn/misc/tensorflow/tensor_shape.pb.cc @@ -0,0 +1,895 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: tensor_shape.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "tensor_shape.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::Descriptor* TensorShapeProto_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TensorShapeProto_reflection_ = NULL; +const ::google::protobuf::Descriptor* TensorShapeProto_Dim_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TensorShapeProto_Dim_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_tensor_5fshape_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_tensor_5fshape_2eproto() { + protobuf_AddDesc_tensor_5fshape_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "tensor_shape.proto"); + GOOGLE_CHECK(file != NULL); + TensorShapeProto_descriptor_ = file->message_type(0); + static const int TensorShapeProto_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorShapeProto, dim_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorShapeProto, unknown_rank_), + }; + TensorShapeProto_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + TensorShapeProto_descriptor_, + TensorShapeProto::internal_default_instance(), + TensorShapeProto_offsets_, + -1, + -1, + -1, + sizeof(TensorShapeProto), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorShapeProto, _internal_metadata_)); + TensorShapeProto_Dim_descriptor_ = TensorShapeProto_descriptor_->nested_type(0); + static const int TensorShapeProto_Dim_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorShapeProto_Dim, size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorShapeProto_Dim, name_), + }; + TensorShapeProto_Dim_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + TensorShapeProto_Dim_descriptor_, + TensorShapeProto_Dim::internal_default_instance(), + TensorShapeProto_Dim_offsets_, + -1, + -1, + -1, + sizeof(TensorShapeProto_Dim), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorShapeProto_Dim, _internal_metadata_)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_tensor_5fshape_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TensorShapeProto_descriptor_, TensorShapeProto::internal_default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TensorShapeProto_Dim_descriptor_, TensorShapeProto_Dim::internal_default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_tensor_5fshape_2eproto() { + TensorShapeProto_default_instance_.Shutdown(); + delete TensorShapeProto_reflection_; + TensorShapeProto_Dim_default_instance_.Shutdown(); + delete TensorShapeProto_Dim_reflection_; +} + +void protobuf_InitDefaults_tensor_5fshape_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + TensorShapeProto_default_instance_.DefaultConstruct(); + ::google::protobuf::internal::GetEmptyString(); + TensorShapeProto_Dim_default_instance_.DefaultConstruct(); + TensorShapeProto_default_instance_.get_mutable()->InitAsDefaultInstance(); + TensorShapeProto_Dim_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_tensor_5fshape_2eproto_once_); +void protobuf_InitDefaults_tensor_5fshape_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_tensor_5fshape_2eproto_once_, + &protobuf_InitDefaults_tensor_5fshape_2eproto_impl); +} +void protobuf_AddDesc_tensor_5fshape_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_tensor_5fshape_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\022tensor_shape.proto\022\ntensorflow\"z\n\020Tens" + "orShapeProto\022-\n\003dim\030\002 \003(\0132 .tensorflow.T" + "ensorShapeProto.Dim\022\024\n\014unknown_rank\030\003 \001(" + "\010\032!\n\003Dim\022\014\n\004size\030\001 \001(\003\022\014\n\004name\030\002 \001(\tB2\n\030" + "org.tensorflow.frameworkB\021TensorShapePro" + "tosP\001\370\001\001b\006proto3", 216); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "tensor_shape.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_tensor_5fshape_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_tensor_5fshape_2eproto_once_); +void protobuf_AddDesc_tensor_5fshape_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_tensor_5fshape_2eproto_once_, + &protobuf_AddDesc_tensor_5fshape_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_tensor_5fshape_2eproto { + StaticDescriptorInitializer_tensor_5fshape_2eproto() { + protobuf_AddDesc_tensor_5fshape_2eproto(); + } +} static_descriptor_initializer_tensor_5fshape_2eproto_; + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TensorShapeProto_Dim::kSizeFieldNumber; +const int TensorShapeProto_Dim::kNameFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TensorShapeProto_Dim::TensorShapeProto_Dim() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_tensor_5fshape_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.TensorShapeProto.Dim) +} +TensorShapeProto_Dim::TensorShapeProto_Dim(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_tensor_5fshape_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.TensorShapeProto.Dim) +} + +void TensorShapeProto_Dim::InitAsDefaultInstance() { +} + +TensorShapeProto_Dim::TensorShapeProto_Dim(const TensorShapeProto_Dim& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.TensorShapeProto.Dim) +} + +void TensorShapeProto_Dim::SharedCtor() { + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + size_ = GOOGLE_LONGLONG(0); + _cached_size_ = 0; +} + +TensorShapeProto_Dim::~TensorShapeProto_Dim() { + // @@protoc_insertion_point(destructor:tensorflow.TensorShapeProto.Dim) + SharedDtor(); +} + +void TensorShapeProto_Dim::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + + name_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); +} + +void TensorShapeProto_Dim::ArenaDtor(void* object) { + TensorShapeProto_Dim* _this = reinterpret_cast< TensorShapeProto_Dim* >(object); + (void)_this; +} +void TensorShapeProto_Dim::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void TensorShapeProto_Dim::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TensorShapeProto_Dim::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TensorShapeProto_Dim_descriptor_; +} + +const TensorShapeProto_Dim& TensorShapeProto_Dim::default_instance() { + protobuf_InitDefaults_tensor_5fshape_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed TensorShapeProto_Dim_default_instance_; + +TensorShapeProto_Dim* TensorShapeProto_Dim::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void TensorShapeProto_Dim::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.TensorShapeProto.Dim) + size_ = GOOGLE_LONGLONG(0); + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} + +bool TensorShapeProto_Dim::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.TensorShapeProto.Dim) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int64 size = 1; + case 1: { + if (tag == 8) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_name; + break; + } + + // optional string name = 2; + case 2: { + if (tag == 18) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::PARSE, + "tensorflow.TensorShapeProto.Dim.name")); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.TensorShapeProto.Dim) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.TensorShapeProto.Dim) + return false; +#undef DO_ +} + +void TensorShapeProto_Dim::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.TensorShapeProto.Dim) + // optional int64 size = 1; + if (this->size() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // optional string name = 2; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.TensorShapeProto.Dim.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->name(), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.TensorShapeProto.Dim) +} + +::google::protobuf::uint8* TensorShapeProto_Dim::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TensorShapeProto.Dim) + // optional int64 size = 1; + if (this->size() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->size(), target); + } + + // optional string name = 2; + if (this->name().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "tensorflow.TensorShapeProto.Dim.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->name(), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TensorShapeProto.Dim) + return target; +} + +size_t TensorShapeProto_Dim::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.TensorShapeProto.Dim) + size_t total_size = 0; + + // optional int64 size = 1; + if (this->size() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // optional string name = 2; + if (this->name().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TensorShapeProto_Dim::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.TensorShapeProto.Dim) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const TensorShapeProto_Dim* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.TensorShapeProto.Dim) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.TensorShapeProto.Dim) + UnsafeMergeFrom(*source); + } +} + +void TensorShapeProto_Dim::MergeFrom(const TensorShapeProto_Dim& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TensorShapeProto.Dim) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void TensorShapeProto_Dim::UnsafeMergeFrom(const TensorShapeProto_Dim& from) { + GOOGLE_DCHECK(&from != this); + if (from.size() != 0) { + set_size(from.size()); + } + if (from.name().size() > 0) { + set_name(from.name()); + } +} + +void TensorShapeProto_Dim::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.TensorShapeProto.Dim) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TensorShapeProto_Dim::CopyFrom(const TensorShapeProto_Dim& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TensorShapeProto.Dim) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool TensorShapeProto_Dim::IsInitialized() const { + + return true; +} + +void TensorShapeProto_Dim::Swap(TensorShapeProto_Dim* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + TensorShapeProto_Dim temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void TensorShapeProto_Dim::UnsafeArenaSwap(TensorShapeProto_Dim* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void TensorShapeProto_Dim::InternalSwap(TensorShapeProto_Dim* other) { + std::swap(size_, other->size_); + name_.Swap(&other->name_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TensorShapeProto_Dim::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TensorShapeProto_Dim_descriptor_; + metadata.reflection = TensorShapeProto_Dim_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TensorShapeProto::kDimFieldNumber; +const int TensorShapeProto::kUnknownRankFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TensorShapeProto::TensorShapeProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_tensor_5fshape_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.TensorShapeProto) +} +TensorShapeProto::TensorShapeProto(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + dim_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_tensor_5fshape_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.TensorShapeProto) +} + +void TensorShapeProto::InitAsDefaultInstance() { +} + +TensorShapeProto::TensorShapeProto(const TensorShapeProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.TensorShapeProto) +} + +void TensorShapeProto::SharedCtor() { + unknown_rank_ = false; + _cached_size_ = 0; +} + +TensorShapeProto::~TensorShapeProto() { + // @@protoc_insertion_point(destructor:tensorflow.TensorShapeProto) + SharedDtor(); +} + +void TensorShapeProto::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + +} + +void TensorShapeProto::ArenaDtor(void* object) { + TensorShapeProto* _this = reinterpret_cast< TensorShapeProto* >(object); + (void)_this; +} +void TensorShapeProto::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void TensorShapeProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TensorShapeProto::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TensorShapeProto_descriptor_; +} + +const TensorShapeProto& TensorShapeProto::default_instance() { + protobuf_InitDefaults_tensor_5fshape_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed TensorShapeProto_default_instance_; + +TensorShapeProto* TensorShapeProto::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void TensorShapeProto::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.TensorShapeProto) + unknown_rank_ = false; + dim_.Clear(); +} + +bool TensorShapeProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.TensorShapeProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .tensorflow.TensorShapeProto.Dim dim = 2; + case 2: { + if (tag == 18) { + DO_(input->IncrementRecursionDepth()); + parse_loop_dim: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( + input, add_dim())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_loop_dim; + input->UnsafeDecrementRecursionDepth(); + if (input->ExpectTag(24)) goto parse_unknown_rank; + break; + } + + // optional bool unknown_rank = 3; + case 3: { + if (tag == 24) { + parse_unknown_rank: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &unknown_rank_))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.TensorShapeProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.TensorShapeProto) + return false; +#undef DO_ +} + +void TensorShapeProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.TensorShapeProto) + // repeated .tensorflow.TensorShapeProto.Dim dim = 2; + for (unsigned int i = 0, n = this->dim_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->dim(i), output); + } + + // optional bool unknown_rank = 3; + if (this->unknown_rank() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->unknown_rank(), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.TensorShapeProto) +} + +::google::protobuf::uint8* TensorShapeProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TensorShapeProto) + // repeated .tensorflow.TensorShapeProto.Dim dim = 2; + for (unsigned int i = 0, n = this->dim_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageNoVirtualToArray( + 2, this->dim(i), false, target); + } + + // optional bool unknown_rank = 3; + if (this->unknown_rank() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->unknown_rank(), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TensorShapeProto) + return target; +} + +size_t TensorShapeProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.TensorShapeProto) + size_t total_size = 0; + + // optional bool unknown_rank = 3; + if (this->unknown_rank() != 0) { + total_size += 1 + 1; + } + + // repeated .tensorflow.TensorShapeProto.Dim dim = 2; + { + unsigned int count = this->dim_size(); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->dim(i)); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TensorShapeProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.TensorShapeProto) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const TensorShapeProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.TensorShapeProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.TensorShapeProto) + UnsafeMergeFrom(*source); + } +} + +void TensorShapeProto::MergeFrom(const TensorShapeProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TensorShapeProto) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void TensorShapeProto::UnsafeMergeFrom(const TensorShapeProto& from) { + GOOGLE_DCHECK(&from != this); + dim_.MergeFrom(from.dim_); + if (from.unknown_rank() != 0) { + set_unknown_rank(from.unknown_rank()); + } +} + +void TensorShapeProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.TensorShapeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TensorShapeProto::CopyFrom(const TensorShapeProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TensorShapeProto) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool TensorShapeProto::IsInitialized() const { + + return true; +} + +void TensorShapeProto::Swap(TensorShapeProto* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + TensorShapeProto temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void TensorShapeProto::UnsafeArenaSwap(TensorShapeProto* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void TensorShapeProto::InternalSwap(TensorShapeProto* other) { + dim_.UnsafeArenaSwap(&other->dim_); + std::swap(unknown_rank_, other->unknown_rank_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TensorShapeProto::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TensorShapeProto_descriptor_; + metadata.reflection = TensorShapeProto_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// TensorShapeProto_Dim + +// optional int64 size = 1; +void TensorShapeProto_Dim::clear_size() { + size_ = GOOGLE_LONGLONG(0); +} +::google::protobuf::int64 TensorShapeProto_Dim::size() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.Dim.size) + return size_; +} +void TensorShapeProto_Dim::set_size(::google::protobuf::int64 value) { + + size_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.Dim.size) +} + +// optional string name = 2; +void TensorShapeProto_Dim::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +const ::std::string& TensorShapeProto_Dim::name() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.Dim.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +void TensorShapeProto_Dim::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.Dim.name) +} +void TensorShapeProto_Dim::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.TensorShapeProto.Dim.name) +} +void TensorShapeProto_Dim::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorShapeProto.Dim.name) +} +::std::string* TensorShapeProto_Dim::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.TensorShapeProto.Dim.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* TensorShapeProto_Dim::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.TensorShapeProto.Dim.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +::std::string* TensorShapeProto_Dim::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorShapeProto.Dim.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +void TensorShapeProto_Dim::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorShapeProto.Dim.name) +} +void TensorShapeProto_Dim::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorShapeProto.Dim.name) +} + +inline const TensorShapeProto_Dim* TensorShapeProto_Dim::internal_default_instance() { + return &TensorShapeProto_Dim_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// TensorShapeProto + +// repeated .tensorflow.TensorShapeProto.Dim dim = 2; +int TensorShapeProto::dim_size() const { + return dim_.size(); +} +void TensorShapeProto::clear_dim() { + dim_.Clear(); +} +const ::tensorflow::TensorShapeProto_Dim& TensorShapeProto::dim(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.dim) + return dim_.Get(index); +} +::tensorflow::TensorShapeProto_Dim* TensorShapeProto::mutable_dim(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.TensorShapeProto.dim) + return dim_.Mutable(index); +} +::tensorflow::TensorShapeProto_Dim* TensorShapeProto::add_dim() { + // @@protoc_insertion_point(field_add:tensorflow.TensorShapeProto.dim) + return dim_.Add(); +} +::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >* +TensorShapeProto::mutable_dim() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorShapeProto.dim) + return &dim_; +} +const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >& +TensorShapeProto::dim() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorShapeProto.dim) + return dim_; +} + +// optional bool unknown_rank = 3; +void TensorShapeProto::clear_unknown_rank() { + unknown_rank_ = false; +} +bool TensorShapeProto::unknown_rank() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.unknown_rank) + return unknown_rank_; +} +void TensorShapeProto::set_unknown_rank(bool value) { + + unknown_rank_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.unknown_rank) +} + +inline const TensorShapeProto* TensorShapeProto::internal_default_instance() { + return &TensorShapeProto_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/tensor_shape.pb.h b/modules/dnn/misc/tensorflow/tensor_shape.pb.h new file mode 100644 index 0000000000..df66bfccae --- /dev/null +++ b/modules/dnn/misc/tensorflow/tensor_shape.pb.h @@ -0,0 +1,423 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: tensor_shape.proto + +#ifndef PROTOBUF_tensor_5fshape_2eproto__INCLUDED +#define PROTOBUF_tensor_5fshape_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_tensor_5fshape_2eproto(); +void protobuf_InitDefaults_tensor_5fshape_2eproto(); +void protobuf_AssignDesc_tensor_5fshape_2eproto(); +void protobuf_ShutdownFile_tensor_5fshape_2eproto(); + +class TensorShapeProto; +class TensorShapeProto_Dim; + +// =================================================================== + +class TensorShapeProto_Dim : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorShapeProto.Dim) */ { + public: + TensorShapeProto_Dim(); + virtual ~TensorShapeProto_Dim(); + + TensorShapeProto_Dim(const TensorShapeProto_Dim& from); + + inline TensorShapeProto_Dim& operator=(const TensorShapeProto_Dim& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const TensorShapeProto_Dim& default_instance(); + + static const TensorShapeProto_Dim* internal_default_instance(); + + void UnsafeArenaSwap(TensorShapeProto_Dim* other); + void Swap(TensorShapeProto_Dim* other); + + // implements Message ---------------------------------------------- + + inline TensorShapeProto_Dim* New() const { return New(NULL); } + + TensorShapeProto_Dim* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TensorShapeProto_Dim& from); + void MergeFrom(const TensorShapeProto_Dim& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorShapeProto_Dim* other); + void UnsafeMergeFrom(const TensorShapeProto_Dim& from); + protected: + explicit TensorShapeProto_Dim(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int64 size = 1; + void clear_size(); + static const int kSizeFieldNumber = 1; + ::google::protobuf::int64 size() const; + void set_size(::google::protobuf::int64 value); + + // optional string name = 2; + void clear_name(); + static const int kNameFieldNumber = 2; + const ::std::string& name() const; + void set_name(const ::std::string& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + ::std::string* mutable_name(); + ::std::string* release_name(); + void set_allocated_name(::std::string* name); + ::std::string* unsafe_arena_release_name(); + void unsafe_arena_set_allocated_name( + ::std::string* name); + + // @@protoc_insertion_point(class_scope:tensorflow.TensorShapeProto.Dim) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::int64 size_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_tensor_5fshape_2eproto_impl(); + friend void protobuf_AddDesc_tensor_5fshape_2eproto_impl(); + friend void protobuf_AssignDesc_tensor_5fshape_2eproto(); + friend void protobuf_ShutdownFile_tensor_5fshape_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed TensorShapeProto_Dim_default_instance_; + +// ------------------------------------------------------------------- + +class TensorShapeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorShapeProto) */ { + public: + TensorShapeProto(); + virtual ~TensorShapeProto(); + + TensorShapeProto(const TensorShapeProto& from); + + inline TensorShapeProto& operator=(const TensorShapeProto& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const TensorShapeProto& default_instance(); + + static const TensorShapeProto* internal_default_instance(); + + void UnsafeArenaSwap(TensorShapeProto* other); + void Swap(TensorShapeProto* other); + + // implements Message ---------------------------------------------- + + inline TensorShapeProto* New() const { return New(NULL); } + + TensorShapeProto* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TensorShapeProto& from); + void MergeFrom(const TensorShapeProto& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorShapeProto* other); + void UnsafeMergeFrom(const TensorShapeProto& from); + protected: + explicit TensorShapeProto(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef TensorShapeProto_Dim Dim; + + // accessors ------------------------------------------------------- + + // repeated .tensorflow.TensorShapeProto.Dim dim = 2; + int dim_size() const; + void clear_dim(); + static const int kDimFieldNumber = 2; + const ::tensorflow::TensorShapeProto_Dim& dim(int index) const; + ::tensorflow::TensorShapeProto_Dim* mutable_dim(int index); + ::tensorflow::TensorShapeProto_Dim* add_dim(); + ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >* + mutable_dim(); + const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >& + dim() const; + + // optional bool unknown_rank = 3; + void clear_unknown_rank(); + static const int kUnknownRankFieldNumber = 3; + bool unknown_rank() const; + void set_unknown_rank(bool value); + + // @@protoc_insertion_point(class_scope:tensorflow.TensorShapeProto) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim > dim_; + bool unknown_rank_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_tensor_5fshape_2eproto_impl(); + friend void protobuf_AddDesc_tensor_5fshape_2eproto_impl(); + friend void protobuf_AssignDesc_tensor_5fshape_2eproto(); + friend void protobuf_ShutdownFile_tensor_5fshape_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed TensorShapeProto_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// TensorShapeProto_Dim + +// optional int64 size = 1; +inline void TensorShapeProto_Dim::clear_size() { + size_ = GOOGLE_LONGLONG(0); +} +inline ::google::protobuf::int64 TensorShapeProto_Dim::size() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.Dim.size) + return size_; +} +inline void TensorShapeProto_Dim::set_size(::google::protobuf::int64 value) { + + size_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.Dim.size) +} + +// optional string name = 2; +inline void TensorShapeProto_Dim::clear_name() { + name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline const ::std::string& TensorShapeProto_Dim::name() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.Dim.name) + return name_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void TensorShapeProto_Dim::set_name(const ::std::string& value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.Dim.name) +} +inline void TensorShapeProto_Dim::set_name(const char* value) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_char:tensorflow.TensorShapeProto.Dim.name) +} +inline void TensorShapeProto_Dim::set_name(const char* value, + size_t size) { + + name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorShapeProto.Dim.name) +} +inline ::std::string* TensorShapeProto_Dim::mutable_name() { + + // @@protoc_insertion_point(field_mutable:tensorflow.TensorShapeProto.Dim.name) + return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* TensorShapeProto_Dim::release_name() { + // @@protoc_insertion_point(field_release:tensorflow.TensorShapeProto.Dim.name) + + return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); +} +inline ::std::string* TensorShapeProto_Dim::unsafe_arena_release_name() { + // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorShapeProto.Dim.name) + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + + return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} +inline void TensorShapeProto_Dim::set_allocated_name(::std::string* name) { + if (name != NULL) { + + } else { + + } + name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name, + GetArenaNoVirtual()); + // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorShapeProto.Dim.name) +} +inline void TensorShapeProto_Dim::unsafe_arena_set_allocated_name( + ::std::string* name) { + GOOGLE_DCHECK(GetArenaNoVirtual() != NULL); + if (name != NULL) { + + } else { + + } + name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + name, GetArenaNoVirtual()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorShapeProto.Dim.name) +} + +inline const TensorShapeProto_Dim* TensorShapeProto_Dim::internal_default_instance() { + return &TensorShapeProto_Dim_default_instance_.get(); +} +// ------------------------------------------------------------------- + +// TensorShapeProto + +// repeated .tensorflow.TensorShapeProto.Dim dim = 2; +inline int TensorShapeProto::dim_size() const { + return dim_.size(); +} +inline void TensorShapeProto::clear_dim() { + dim_.Clear(); +} +inline const ::tensorflow::TensorShapeProto_Dim& TensorShapeProto::dim(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.dim) + return dim_.Get(index); +} +inline ::tensorflow::TensorShapeProto_Dim* TensorShapeProto::mutable_dim(int index) { + // @@protoc_insertion_point(field_mutable:tensorflow.TensorShapeProto.dim) + return dim_.Mutable(index); +} +inline ::tensorflow::TensorShapeProto_Dim* TensorShapeProto::add_dim() { + // @@protoc_insertion_point(field_add:tensorflow.TensorShapeProto.dim) + return dim_.Add(); +} +inline ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >* +TensorShapeProto::mutable_dim() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorShapeProto.dim) + return &dim_; +} +inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >& +TensorShapeProto::dim() const { + // @@protoc_insertion_point(field_list:tensorflow.TensorShapeProto.dim) + return dim_; +} + +// optional bool unknown_rank = 3; +inline void TensorShapeProto::clear_unknown_rank() { + unknown_rank_ = false; +} +inline bool TensorShapeProto::unknown_rank() const { + // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.unknown_rank) + return unknown_rank_; +} +inline void TensorShapeProto::set_unknown_rank(bool value) { + + unknown_rank_ = value; + // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.unknown_rank) +} + +inline const TensorShapeProto* TensorShapeProto::internal_default_instance() { + return &TensorShapeProto_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_tensor_5fshape_2eproto__INCLUDED diff --git a/modules/dnn/misc/tensorflow/types.pb.cc b/modules/dnn/misc/tensorflow/types.pb.cc new file mode 100644 index 0000000000..0e509cc200 --- /dev/null +++ b/modules/dnn/misc/tensorflow/types.pb.cc @@ -0,0 +1,163 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "types.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::EnumDescriptor* DataType_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_types_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_types_2eproto() { + protobuf_AddDesc_types_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "types.proto"); + GOOGLE_CHECK(file != NULL); + DataType_descriptor_ = file->enum_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_types_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); +} + +} // namespace + +void protobuf_ShutdownFile_types_2eproto() { +} + +void protobuf_InitDefaults_types_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_types_2eproto_once_); +void protobuf_InitDefaults_types_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_types_2eproto_once_, + &protobuf_InitDefaults_types_2eproto_impl); +} +void protobuf_AddDesc_types_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_types_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\013types.proto\022\ntensorflow*\234\005\n\010DataType\022\016" + "\n\nDT_INVALID\020\000\022\014\n\010DT_FLOAT\020\001\022\r\n\tDT_DOUBL" + "E\020\002\022\014\n\010DT_INT32\020\003\022\014\n\010DT_UINT8\020\004\022\014\n\010DT_IN" + "T16\020\005\022\013\n\007DT_INT8\020\006\022\r\n\tDT_STRING\020\007\022\020\n\014DT_" + "COMPLEX64\020\010\022\014\n\010DT_INT64\020\t\022\013\n\007DT_BOOL\020\n\022\014" + "\n\010DT_QINT8\020\013\022\r\n\tDT_QUINT8\020\014\022\r\n\tDT_QINT32" + "\020\r\022\017\n\013DT_BFLOAT16\020\016\022\r\n\tDT_QINT16\020\017\022\016\n\nDT" + "_QUINT16\020\020\022\r\n\tDT_UINT16\020\021\022\021\n\rDT_COMPLEX1" + "28\020\022\022\013\n\007DT_HALF\020\023\022\020\n\014DT_FLOAT_REF\020e\022\021\n\rD" + "T_DOUBLE_REF\020f\022\020\n\014DT_INT32_REF\020g\022\020\n\014DT_U" + "INT8_REF\020h\022\020\n\014DT_INT16_REF\020i\022\017\n\013DT_INT8_" + "REF\020j\022\021\n\rDT_STRING_REF\020k\022\024\n\020DT_COMPLEX64" + "_REF\020l\022\020\n\014DT_INT64_REF\020m\022\017\n\013DT_BOOL_REF\020" + "n\022\020\n\014DT_QINT8_REF\020o\022\021\n\rDT_QUINT8_REF\020p\022\021" + "\n\rDT_QINT32_REF\020q\022\023\n\017DT_BFLOAT16_REF\020r\022\021" + "\n\rDT_QINT16_REF\020s\022\022\n\016DT_QUINT16_REF\020t\022\021\n" + "\rDT_UINT16_REF\020u\022\025\n\021DT_COMPLEX128_REF\020v\022" + "\017\n\013DT_HALF_REF\020wB,\n\030org.tensorflow.frame" + "workB\013TypesProtosP\001\370\001\001b\006proto3", 750); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "types.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_types_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_types_2eproto_once_); +void protobuf_AddDesc_types_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_types_2eproto_once_, + &protobuf_AddDesc_types_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_types_2eproto { + StaticDescriptorInitializer_types_2eproto() { + protobuf_AddDesc_types_2eproto(); + } +} static_descriptor_initializer_types_2eproto_; +const ::google::protobuf::EnumDescriptor* DataType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return DataType_descriptor_; +} +bool DataType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + return true; + default: + return false; + } +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/types.pb.h b/modules/dnn/misc/tensorflow/types.pb.h new file mode 100644 index 0000000000..40ed7b856f --- /dev/null +++ b/modules/dnn/misc/tensorflow/types.pb.h @@ -0,0 +1,129 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: types.proto + +#ifndef PROTOBUF_types_2eproto__INCLUDED +#define PROTOBUF_types_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_types_2eproto(); +void protobuf_InitDefaults_types_2eproto(); +void protobuf_AssignDesc_types_2eproto(); +void protobuf_ShutdownFile_types_2eproto(); + + +enum DataType { + DT_INVALID = 0, + DT_FLOAT = 1, + DT_DOUBLE = 2, + DT_INT32 = 3, + DT_UINT8 = 4, + DT_INT16 = 5, + DT_INT8 = 6, + DT_STRING = 7, + DT_COMPLEX64 = 8, + DT_INT64 = 9, + DT_BOOL = 10, + DT_QINT8 = 11, + DT_QUINT8 = 12, + DT_QINT32 = 13, + DT_BFLOAT16 = 14, + DT_QINT16 = 15, + DT_QUINT16 = 16, + DT_UINT16 = 17, + DT_COMPLEX128 = 18, + DT_HALF = 19, + DT_FLOAT_REF = 101, + DT_DOUBLE_REF = 102, + DT_INT32_REF = 103, + DT_UINT8_REF = 104, + DT_INT16_REF = 105, + DT_INT8_REF = 106, + DT_STRING_REF = 107, + DT_COMPLEX64_REF = 108, + DT_INT64_REF = 109, + DT_BOOL_REF = 110, + DT_QINT8_REF = 111, + DT_QUINT8_REF = 112, + DT_QINT32_REF = 113, + DT_BFLOAT16_REF = 114, + DT_QINT16_REF = 115, + DT_QUINT16_REF = 116, + DT_UINT16_REF = 117, + DT_COMPLEX128_REF = 118, + DT_HALF_REF = 119, + DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min, + DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max +}; +bool DataType_IsValid(int value); +const DataType DataType_MIN = DT_INVALID; +const DataType DataType_MAX = DT_HALF_REF; +const int DataType_ARRAYSIZE = DataType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* DataType_descriptor(); +inline const ::std::string& DataType_Name(DataType value) { + return ::google::protobuf::internal::NameOfEnum( + DataType_descriptor(), value); +} +inline bool DataType_Parse( + const ::std::string& name, DataType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + DataType_descriptor(), name, value); +} +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::tensorflow::DataType> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::DataType>() { + return ::tensorflow::DataType_descriptor(); +} + +} // namespace protobuf +} // namespace google +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_types_2eproto__INCLUDED diff --git a/modules/dnn/misc/tensorflow/versions.pb.cc b/modules/dnn/misc/tensorflow/versions.pb.cc new file mode 100644 index 0000000000..a4556a0ff7 --- /dev/null +++ b/modules/dnn/misc/tensorflow/versions.pb.cc @@ -0,0 +1,572 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: versions.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "versions.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +namespace { + +const ::google::protobuf::Descriptor* VersionDef_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + VersionDef_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_versions_2eproto() GOOGLE_ATTRIBUTE_COLD; +void protobuf_AssignDesc_versions_2eproto() { + protobuf_AddDesc_versions_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "versions.proto"); + GOOGLE_CHECK(file != NULL); + VersionDef_descriptor_ = file->message_type(0); + static const int VersionDef_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionDef, producer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionDef, min_consumer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionDef, bad_consumers_), + }; + VersionDef_reflection_ = + ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection( + VersionDef_descriptor_, + VersionDef::internal_default_instance(), + VersionDef_offsets_, + -1, + -1, + -1, + sizeof(VersionDef), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionDef, _internal_metadata_)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_versions_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + VersionDef_descriptor_, VersionDef::internal_default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_versions_2eproto() { + VersionDef_default_instance_.Shutdown(); + delete VersionDef_reflection_; +} + +void protobuf_InitDefaults_versions_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + VersionDef_default_instance_.DefaultConstruct(); + VersionDef_default_instance_.get_mutable()->InitAsDefaultInstance(); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_versions_2eproto_once_); +void protobuf_InitDefaults_versions_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_versions_2eproto_once_, + &protobuf_InitDefaults_versions_2eproto_impl); +} +void protobuf_AddDesc_versions_2eproto_impl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + protobuf_InitDefaults_versions_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\016versions.proto\022\ntensorflow\"K\n\nVersionD" + "ef\022\020\n\010producer\030\001 \001(\005\022\024\n\014min_consumer\030\002 \001" + "(\005\022\025\n\rbad_consumers\030\003 \003(\005B/\n\030org.tensorf" + "low.frameworkB\016VersionsProtosP\001\370\001\001b\006prot" + "o3", 162); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "versions.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_versions_2eproto); +} + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_versions_2eproto_once_); +void protobuf_AddDesc_versions_2eproto() { + ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_versions_2eproto_once_, + &protobuf_AddDesc_versions_2eproto_impl); +} +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_versions_2eproto { + StaticDescriptorInitializer_versions_2eproto() { + protobuf_AddDesc_versions_2eproto(); + } +} static_descriptor_initializer_versions_2eproto_; + +namespace { + +static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN; +static void MergeFromFail(int line) { + ::google::protobuf::internal::MergeFromFail(__FILE__, line); +} + +} // namespace + + +// =================================================================== + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int VersionDef::kProducerFieldNumber; +const int VersionDef::kMinConsumerFieldNumber; +const int VersionDef::kBadConsumersFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +VersionDef::VersionDef() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (this != internal_default_instance()) protobuf_InitDefaults_versions_2eproto(); + SharedCtor(); + // @@protoc_insertion_point(constructor:tensorflow.VersionDef) +} +VersionDef::VersionDef(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(), + _internal_metadata_(arena), + bad_consumers_(arena) { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_InitDefaults_versions_2eproto(); +#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tensorflow.VersionDef) +} + +void VersionDef::InitAsDefaultInstance() { +} + +VersionDef::VersionDef(const VersionDef& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + SharedCtor(); + UnsafeMergeFrom(from); + // @@protoc_insertion_point(copy_constructor:tensorflow.VersionDef) +} + +void VersionDef::SharedCtor() { + ::memset(&producer_, 0, reinterpret_cast(&min_consumer_) - + reinterpret_cast(&producer_) + sizeof(min_consumer_)); + _cached_size_ = 0; +} + +VersionDef::~VersionDef() { + // @@protoc_insertion_point(destructor:tensorflow.VersionDef) + SharedDtor(); +} + +void VersionDef::SharedDtor() { + ::google::protobuf::Arena* arena = GetArenaNoVirtual(); + if (arena != NULL) { + return; + } + +} + +void VersionDef::ArenaDtor(void* object) { + VersionDef* _this = reinterpret_cast< VersionDef* >(object); + (void)_this; +} +void VersionDef::RegisterArenaDtor(::google::protobuf::Arena* arena) { +} +void VersionDef::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* VersionDef::descriptor() { + protobuf_AssignDescriptorsOnce(); + return VersionDef_descriptor_; +} + +const VersionDef& VersionDef::default_instance() { + protobuf_InitDefaults_versions_2eproto(); + return *internal_default_instance(); +} + +::google::protobuf::internal::ExplicitlyConstructed VersionDef_default_instance_; + +VersionDef* VersionDef::New(::google::protobuf::Arena* arena) const { + return ::google::protobuf::Arena::CreateMessage(arena); +} + +void VersionDef::Clear() { +// @@protoc_insertion_point(message_clear_start:tensorflow.VersionDef) +#if defined(__clang__) +#define ZR_HELPER_(f) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(VersionDef, f) \ + _Pragma("clang diagnostic pop") +#else +#define ZR_HELPER_(f) reinterpret_cast(\ + &reinterpret_cast(16)->f) +#endif + +#define ZR_(first, last) do {\ + ::memset(&(first), 0,\ + ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ +} while (0) + + ZR_(producer_, min_consumer_); + +#undef ZR_HELPER_ +#undef ZR_ + + bad_consumers_.Clear(); +} + +bool VersionDef::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:tensorflow.VersionDef) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int32 producer = 1; + case 1: { + if (tag == 8) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &producer_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_min_consumer; + break; + } + + // optional int32 min_consumer = 2; + case 2: { + if (tag == 16) { + parse_min_consumer: + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &min_consumer_))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_bad_consumers; + break; + } + + // repeated int32 bad_consumers = 3; + case 3: { + if (tag == 26) { + parse_bad_consumers: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_bad_consumers()))); + } else if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 26, input, this->mutable_bad_consumers()))); + } else { + goto handle_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:tensorflow.VersionDef) + return true; +failure: + // @@protoc_insertion_point(parse_failure:tensorflow.VersionDef) + return false; +#undef DO_ +} + +void VersionDef::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:tensorflow.VersionDef) + // optional int32 producer = 1; + if (this->producer() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->producer(), output); + } + + // optional int32 min_consumer = 2; + if (this->min_consumer() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->min_consumer(), output); + } + + // repeated int32 bad_consumers = 3; + if (this->bad_consumers_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_bad_consumers_cached_byte_size_); + } + for (int i = 0; i < this->bad_consumers_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag( + this->bad_consumers(i), output); + } + + // @@protoc_insertion_point(serialize_end:tensorflow.VersionDef) +} + +::google::protobuf::uint8* VersionDef::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:tensorflow.VersionDef) + // optional int32 producer = 1; + if (this->producer() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->producer(), target); + } + + // optional int32 min_consumer = 2; + if (this->min_consumer() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->min_consumer(), target); + } + + // repeated int32 bad_consumers = 3; + if (this->bad_consumers_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 3, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _bad_consumers_cached_byte_size_, target); + } + for (int i = 0; i < this->bad_consumers_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32NoTagToArray(this->bad_consumers(i), target); + } + + // @@protoc_insertion_point(serialize_to_array_end:tensorflow.VersionDef) + return target; +} + +size_t VersionDef::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tensorflow.VersionDef) + size_t total_size = 0; + + // optional int32 producer = 1; + if (this->producer() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->producer()); + } + + // optional int32 min_consumer = 2; + if (this->min_consumer() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->min_consumer()); + } + + // repeated int32 bad_consumers = 3; + { + size_t data_size = 0; + unsigned int count = this->bad_consumers_size(); + for (unsigned int i = 0; i < count; i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->bad_consumers(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _bad_consumers_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void VersionDef::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.VersionDef) + if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); + const VersionDef* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.VersionDef) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.VersionDef) + UnsafeMergeFrom(*source); + } +} + +void VersionDef::MergeFrom(const VersionDef& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.VersionDef) + if (GOOGLE_PREDICT_TRUE(&from != this)) { + UnsafeMergeFrom(from); + } else { + MergeFromFail(__LINE__); + } +} + +void VersionDef::UnsafeMergeFrom(const VersionDef& from) { + GOOGLE_DCHECK(&from != this); + bad_consumers_.UnsafeMergeFrom(from.bad_consumers_); + if (from.producer() != 0) { + set_producer(from.producer()); + } + if (from.min_consumer() != 0) { + set_min_consumer(from.min_consumer()); + } +} + +void VersionDef::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.VersionDef) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VersionDef::CopyFrom(const VersionDef& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.VersionDef) + if (&from == this) return; + Clear(); + UnsafeMergeFrom(from); +} + +bool VersionDef::IsInitialized() const { + + return true; +} + +void VersionDef::Swap(VersionDef* other) { + if (other == this) return; + if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { + InternalSwap(other); + } else { + VersionDef temp; + temp.UnsafeMergeFrom(*this); + CopyFrom(*other); + other->CopyFrom(temp); + } +} +void VersionDef::UnsafeArenaSwap(VersionDef* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual()); + InternalSwap(other); +} +void VersionDef::InternalSwap(VersionDef* other) { + std::swap(producer_, other->producer_); + std::swap(min_consumer_, other->min_consumer_); + bad_consumers_.UnsafeArenaSwap(&other->bad_consumers_); + _internal_metadata_.Swap(&other->_internal_metadata_); + std::swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata VersionDef::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = VersionDef_descriptor_; + metadata.reflection = VersionDef_reflection_; + return metadata; +} + +#if PROTOBUF_INLINE_NOT_IN_HEADERS +// VersionDef + +// optional int32 producer = 1; +void VersionDef::clear_producer() { + producer_ = 0; +} +::google::protobuf::int32 VersionDef::producer() const { + // @@protoc_insertion_point(field_get:tensorflow.VersionDef.producer) + return producer_; +} +void VersionDef::set_producer(::google::protobuf::int32 value) { + + producer_ = value; + // @@protoc_insertion_point(field_set:tensorflow.VersionDef.producer) +} + +// optional int32 min_consumer = 2; +void VersionDef::clear_min_consumer() { + min_consumer_ = 0; +} +::google::protobuf::int32 VersionDef::min_consumer() const { + // @@protoc_insertion_point(field_get:tensorflow.VersionDef.min_consumer) + return min_consumer_; +} +void VersionDef::set_min_consumer(::google::protobuf::int32 value) { + + min_consumer_ = value; + // @@protoc_insertion_point(field_set:tensorflow.VersionDef.min_consumer) +} + +// repeated int32 bad_consumers = 3; +int VersionDef::bad_consumers_size() const { + return bad_consumers_.size(); +} +void VersionDef::clear_bad_consumers() { + bad_consumers_.Clear(); +} +::google::protobuf::int32 VersionDef::bad_consumers(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.VersionDef.bad_consumers) + return bad_consumers_.Get(index); +} +void VersionDef::set_bad_consumers(int index, ::google::protobuf::int32 value) { + bad_consumers_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.VersionDef.bad_consumers) +} +void VersionDef::add_bad_consumers(::google::protobuf::int32 value) { + bad_consumers_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.VersionDef.bad_consumers) +} +const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +VersionDef::bad_consumers() const { + // @@protoc_insertion_point(field_list:tensorflow.VersionDef.bad_consumers) + return bad_consumers_; +} +::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +VersionDef::mutable_bad_consumers() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.VersionDef.bad_consumers) + return &bad_consumers_; +} + +inline const VersionDef* VersionDef::internal_default_instance() { + return &VersionDef_default_instance_.get(); +} +#endif // PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/tensorflow/versions.pb.h b/modules/dnn/misc/tensorflow/versions.pb.h new file mode 100644 index 0000000000..ce099cbf48 --- /dev/null +++ b/modules/dnn/misc/tensorflow/versions.pb.h @@ -0,0 +1,239 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: versions.proto + +#ifndef PROTOBUF_versions_2eproto__INCLUDED +#define PROTOBUF_versions_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3001000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tensorflow { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_versions_2eproto(); +void protobuf_InitDefaults_versions_2eproto(); +void protobuf_AssignDesc_versions_2eproto(); +void protobuf_ShutdownFile_versions_2eproto(); + +class VersionDef; + +// =================================================================== + +class VersionDef : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.VersionDef) */ { + public: + VersionDef(); + virtual ~VersionDef(); + + VersionDef(const VersionDef& from); + + inline VersionDef& operator=(const VersionDef& from) { + CopyFrom(from); + return *this; + } + + inline ::google::protobuf::Arena* GetArena() const { return GetArenaNoVirtual(); } + inline void* GetMaybeArenaPointer() const { + return MaybeArenaPtr(); + } + static const ::google::protobuf::Descriptor* descriptor(); + static const VersionDef& default_instance(); + + static const VersionDef* internal_default_instance(); + + void UnsafeArenaSwap(VersionDef* other); + void Swap(VersionDef* other); + + // implements Message ---------------------------------------------- + + inline VersionDef* New() const { return New(NULL); } + + VersionDef* New(::google::protobuf::Arena* arena) const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const VersionDef& from); + void MergeFrom(const VersionDef& from); + void Clear(); + bool IsInitialized() const; + + size_t ByteSizeLong() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const { + return InternalSerializeWithCachedSizesToArray(false, output); + } + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(VersionDef* other); + void UnsafeMergeFrom(const VersionDef& from); + protected: + explicit VersionDef(::google::protobuf::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::google::protobuf::Arena* arena); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return _internal_metadata_.arena(); + } + inline void* MaybeArenaPtr() const { + return _internal_metadata_.raw_arena_ptr(); + } + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 producer = 1; + void clear_producer(); + static const int kProducerFieldNumber = 1; + ::google::protobuf::int32 producer() const; + void set_producer(::google::protobuf::int32 value); + + // optional int32 min_consumer = 2; + void clear_min_consumer(); + static const int kMinConsumerFieldNumber = 2; + ::google::protobuf::int32 min_consumer() const; + void set_min_consumer(::google::protobuf::int32 value); + + // repeated int32 bad_consumers = 3; + int bad_consumers_size() const; + void clear_bad_consumers(); + static const int kBadConsumersFieldNumber = 3; + ::google::protobuf::int32 bad_consumers(int index) const; + void set_bad_consumers(int index, ::google::protobuf::int32 value); + void add_bad_consumers(::google::protobuf::int32 value); + const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + bad_consumers() const; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_bad_consumers(); + + // @@protoc_insertion_point(class_scope:tensorflow.VersionDef) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + friend class ::google::protobuf::Arena; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > bad_consumers_; + mutable int _bad_consumers_cached_byte_size_; + ::google::protobuf::int32 producer_; + ::google::protobuf::int32 min_consumer_; + mutable int _cached_size_; + friend void protobuf_InitDefaults_versions_2eproto_impl(); + friend void protobuf_AddDesc_versions_2eproto_impl(); + friend void protobuf_AssignDesc_versions_2eproto(); + friend void protobuf_ShutdownFile_versions_2eproto(); + + void InitAsDefaultInstance(); +}; +extern ::google::protobuf::internal::ExplicitlyConstructed VersionDef_default_instance_; + +// =================================================================== + + +// =================================================================== + +#if !PROTOBUF_INLINE_NOT_IN_HEADERS +// VersionDef + +// optional int32 producer = 1; +inline void VersionDef::clear_producer() { + producer_ = 0; +} +inline ::google::protobuf::int32 VersionDef::producer() const { + // @@protoc_insertion_point(field_get:tensorflow.VersionDef.producer) + return producer_; +} +inline void VersionDef::set_producer(::google::protobuf::int32 value) { + + producer_ = value; + // @@protoc_insertion_point(field_set:tensorflow.VersionDef.producer) +} + +// optional int32 min_consumer = 2; +inline void VersionDef::clear_min_consumer() { + min_consumer_ = 0; +} +inline ::google::protobuf::int32 VersionDef::min_consumer() const { + // @@protoc_insertion_point(field_get:tensorflow.VersionDef.min_consumer) + return min_consumer_; +} +inline void VersionDef::set_min_consumer(::google::protobuf::int32 value) { + + min_consumer_ = value; + // @@protoc_insertion_point(field_set:tensorflow.VersionDef.min_consumer) +} + +// repeated int32 bad_consumers = 3; +inline int VersionDef::bad_consumers_size() const { + return bad_consumers_.size(); +} +inline void VersionDef::clear_bad_consumers() { + bad_consumers_.Clear(); +} +inline ::google::protobuf::int32 VersionDef::bad_consumers(int index) const { + // @@protoc_insertion_point(field_get:tensorflow.VersionDef.bad_consumers) + return bad_consumers_.Get(index); +} +inline void VersionDef::set_bad_consumers(int index, ::google::protobuf::int32 value) { + bad_consumers_.Set(index, value); + // @@protoc_insertion_point(field_set:tensorflow.VersionDef.bad_consumers) +} +inline void VersionDef::add_bad_consumers(::google::protobuf::int32 value) { + bad_consumers_.Add(value); + // @@protoc_insertion_point(field_add:tensorflow.VersionDef.bad_consumers) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +VersionDef::bad_consumers() const { + // @@protoc_insertion_point(field_list:tensorflow.VersionDef.bad_consumers) + return bad_consumers_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +VersionDef::mutable_bad_consumers() { + // @@protoc_insertion_point(field_mutable_list:tensorflow.VersionDef.bad_consumers) + return &bad_consumers_; +} + +inline const VersionDef* VersionDef::internal_default_instance() { + return &VersionDef_default_instance_.get(); +} +#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tensorflow + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_versions_2eproto__INCLUDED diff --git a/modules/dnn/perf/perf_convolution.cpp b/modules/dnn/perf/perf_convolution.cpp new file mode 100644 index 0000000000..502c5ef822 --- /dev/null +++ b/modules/dnn/perf/perf_convolution.cpp @@ -0,0 +1,106 @@ +#include "perf_precomp.hpp" +#include + +namespace cvtest +{ + +using std::tr1::tuple; +using std::tr1::get; +using std::tr1::make_tuple; +using std::make_pair; +using namespace perf; +using namespace testing; +using namespace cv; +using namespace cv::dnn; + +enum {STRIDE_OFF = 1, STRIDE_ON = 2}; +CV_ENUM(StrideSize, STRIDE_OFF, STRIDE_ON); + +enum {GROUP_OFF = 1, GROUP_2 = 2}; +CV_ENUM(GroupSize, GROUP_OFF, GROUP_2); + +//Squared Size +#define SSZ(n) cv::Size(n, n) + +typedef std::pair InpShapeNumOut; +typedef tuple ConvParam; //kernel_size, inp shape, groups, stride +typedef TestBaseWithParam ConvolutionPerfTest; + +static inline MatShape blobShape(int count, int nplanes, int height, int width) +{ + int data[] = {count, nplanes, height, width}; + return MatShape(data, data+4); +} + +PERF_TEST_P( ConvolutionPerfTest, perf, Combine( + Values(Size(1, 1), Size(3, 3), Size(5, 5), Size(11, 11)), + Values(make_pair(blobShape(1, 4, 224, 224), 64), + make_pair(blobShape(1, 64, 112, 122), 128), + make_pair(blobShape(1, 256, 28, 28), 512)), + GroupSize::all(), + StrideSize::all()) +) +{ + RNG rng(0); + + ConvParam params = GetParam(); + int ksz = get<0>(params).width; + MatShape inpShape = get<1>(params).first; + int outCn = get<1>(params).second; + int groups = get<2>(params); + int stride = (ksz >= 11) ? 4 : (int)get<3>(params); + + int inpCn = inpShape[1]; + int wgtSize[] = { outCn, inpCn/groups, ksz, ksz }; + int biasSize[] = { outCn, 1, 1, 1 }; + const int wtype = CV_32F; + Mat wgtBlob(4, wgtSize, wtype), biasBlob(4, biasSize, wtype); + Mat inpBlob(4, &inpShape[0], wtype); + rng.fill(biasBlob, RNG::UNIFORM, -1, +1); + rng.fill(wgtBlob, RNG::UNIFORM, -1, +1); + rng.fill(inpBlob, RNG::UNIFORM, -1, +1); + + LayerParams lp; + lp.set("num_output", outCn); + lp.set("group", groups); + lp.set("stride", stride); + lp.set("kernel_size", ksz); + lp.blobs.reserve(2); + lp.blobs.push_back(wgtBlob); + lp.blobs.push_back(biasBlob); + + std::vector inpBlobs(1, &inpBlob); + std::vector outBlobs, internalBlobs; + + cv::setNumThreads(cv::getNumberOfCPUs()); + + Ptr layer = cv::dnn::LayerFactory::createLayerInstance("Convolution", lp); + std::vector inputShapes(1, shape(inpBlob)), outShapes, internals; + layer->getMemoryShapes(inputShapes, 0, outShapes, internals); + for (int i = 0; i < outShapes.size(); i++) + { + outBlobs.push_back(Mat(outShapes[i], CV_32F)); + } + for (int i = 0; i < internals.size(); i++) + { + internalBlobs.push_back(Mat()); + if (total(internals[i])) + internalBlobs.back().create(internals[i], CV_32F); + } + + layer->finalize(inpBlobs, outBlobs); + + Mat inpBlob2D = inpBlob.reshape(1, outCn); + Mat wgtBlob2D = wgtBlob.reshape(1, outCn*(inpCn/groups)); + Mat outBlob2D = outBlobs[0].reshape(1, outBlobs[0].size[0]); + declare.in(inpBlob2D, wgtBlob2D, WARMUP_RNG).out(outBlob2D).tbb_threads(cv::getNumThreads()); + + TEST_CYCLE_N(10) + { + layer->forward(inpBlobs, outBlobs, internalBlobs); + } + + SANITY_CHECK_NOTHING(); +} + +} diff --git a/modules/dnn/perf/perf_halide_net.cpp b/modules/dnn/perf/perf_halide_net.cpp new file mode 100644 index 0000000000..5631da6384 --- /dev/null +++ b/modules/dnn/perf/perf_halide_net.cpp @@ -0,0 +1,172 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +namespace cvtest +{ + +#ifdef HAVE_HALIDE +using namespace cv; +using namespace dnn; + +static void loadNet(std::string weights, std::string proto, std::string scheduler, + int inWidth, int inHeight, const std::string& outputLayer, + const std::string& framework, int targetId, Net* net) +{ + Mat input(inHeight, inWidth, CV_32FC3); + randu(input, 0.0f, 1.0f); + + weights = findDataFile(weights, false); + if (!proto.empty()) + proto = findDataFile(proto, false); + if (!scheduler.empty()) + scheduler = findDataFile(scheduler, false); + if (framework == "caffe") + { + *net = cv::dnn::readNetFromCaffe(proto, weights); + } + else if (framework == "torch") + { + *net = cv::dnn::readNetFromTorch(weights); + } + else if (framework == "tensorflow") + { + *net = cv::dnn::readNetFromTensorflow(weights); + } + else + CV_Error(Error::StsNotImplemented, "Unknown framework " + framework); + + net->setInput(blobFromImage(input, 1.0, Size(), Scalar(), false)); + net->setPreferableBackend(DNN_BACKEND_HALIDE); + net->setPreferableTarget(targetId); + net->setHalideScheduler(scheduler); + net->forward(outputLayer); +} + +//////////////////////////////////////////////////////////////////////////////// +// CPU target +//////////////////////////////////////////////////////////////////////////////// +PERF_TEST(GoogLeNet, HalidePerfTest) +{ + Net net; + loadNet("dnn/bvlc_googlenet.caffemodel", "dnn/bvlc_googlenet.prototxt", + "", 227, 227, "prob", "caffe", DNN_TARGET_CPU, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(AlexNet, HalidePerfTest) +{ + Net net; + loadNet("dnn/bvlc_alexnet.caffemodel", "dnn/bvlc_alexnet.prototxt", + "dnn/halide_scheduler_alexnet.yml", 227, 227, "prob", "caffe", + DNN_TARGET_CPU, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(ResNet50, HalidePerfTest) +{ + Net net; + loadNet("dnn/ResNet-50-model.caffemodel", "dnn/ResNet-50-deploy.prototxt", + "dnn/halide_scheduler_resnet_50.yml", 224, 224, "prob", "caffe", + DNN_TARGET_CPU, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(SqueezeNet_v1_1, HalidePerfTest) +{ + Net net; + loadNet("dnn/squeezenet_v1_1.caffemodel", "dnn/squeezenet_v1_1.prototxt", + "dnn/halide_scheduler_squeezenet_v1_1.yml", 227, 227, "prob", + "caffe", DNN_TARGET_CPU, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(Inception_5h, HalidePerfTest) +{ + Net net; + loadNet("dnn/tensorflow_inception_graph.pb", "", + "dnn/halide_scheduler_inception_5h.yml", + 224, 224, "softmax2", "tensorflow", DNN_TARGET_CPU, &net); + TEST_CYCLE() net.forward("softmax2"); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(ENet, HalidePerfTest) +{ + Net net; + loadNet("dnn/Enet-model-best.net", "", "dnn/halide_scheduler_enet.yml", + 512, 256, "l367_Deconvolution", "torch", DNN_TARGET_CPU, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} +//////////////////////////////////////////////////////////////////////////////// +// OpenCL target +//////////////////////////////////////////////////////////////////////////////// +PERF_TEST(GoogLeNet_opencl, HalidePerfTest) +{ + Net net; + loadNet("dnn/bvlc_googlenet.caffemodel", "dnn/bvlc_googlenet.prototxt", + "", 227, 227, "prob", "caffe", DNN_TARGET_OPENCL, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(AlexNet_opencl, HalidePerfTest) +{ + Net net; + loadNet("dnn/bvlc_alexnet.caffemodel", "dnn/bvlc_alexnet.prototxt", + "dnn/halide_scheduler_opencl_alexnet.yml", 227, 227, "prob", "caffe", + DNN_TARGET_OPENCL, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(ResNet50_opencl, HalidePerfTest) +{ + Net net; + loadNet("dnn/ResNet-50-model.caffemodel", "dnn/ResNet-50-deploy.prototxt", + "dnn/halide_scheduler_opencl_resnet_50.yml", 224, 224, "prob", "caffe", + DNN_TARGET_OPENCL, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + + +PERF_TEST(SqueezeNet_v1_1_opencl, HalidePerfTest) +{ + Net net; + loadNet("dnn/squeezenet_v1_1.caffemodel", "dnn/squeezenet_v1_1.prototxt", + "dnn/halide_scheduler_opencl_squeezenet_v1_1.yml", 227, 227, "prob", + "caffe", DNN_TARGET_OPENCL, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(Inception_5h_opencl, HalidePerfTest) +{ + Net net; + loadNet("dnn/tensorflow_inception_graph.pb", "", + "dnn/halide_scheduler_opencl_inception_5h.yml", + 224, 224, "softmax2", "tensorflow", DNN_TARGET_OPENCL, &net); + TEST_CYCLE() net.forward("softmax2"); + SANITY_CHECK_NOTHING(); +} + +PERF_TEST(ENet_opencl, HalidePerfTest) +{ + Net net; + loadNet("dnn/Enet-model-best.net", "", "dnn/halide_scheduler_opencl_enet.yml", + 512, 256, "l367_Deconvolution", "torch", DNN_TARGET_OPENCL, &net); + TEST_CYCLE() net.forward(); + SANITY_CHECK_NOTHING(); +} +#endif // HAVE_HALIDE + +} // namespace cvtest diff --git a/modules/dnn/perf/perf_main.cpp b/modules/dnn/perf/perf_main.cpp new file mode 100644 index 0000000000..d66f19c9dd --- /dev/null +++ b/modules/dnn/perf/perf_main.cpp @@ -0,0 +1,12 @@ +#include "perf_precomp.hpp" + +static const char* extraTestDataPath = +#ifdef WINRT + NULL; +#else + getenv("OPENCV_DNN_TEST_DATA_PATH"); +#endif + +CV_PERF_TEST_MAIN(dnn, + extraTestDataPath ? (void)cvtest::addDataSearchPath(extraTestDataPath) : (void)0 +) diff --git a/modules/dnn/perf/perf_precomp.hpp b/modules/dnn/perf/perf_precomp.hpp new file mode 100644 index 0000000000..5cdbc6d179 --- /dev/null +++ b/modules/dnn/perf/perf_precomp.hpp @@ -0,0 +1,17 @@ +#ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wmissing-declarations" +# if defined __clang__ || defined __APPLE__ +# pragma GCC diagnostic ignored "-Wmissing-prototypes" +# pragma GCC diagnostic ignored "-Wextra" +# endif +#endif + +#ifndef __OPENCV_PERF_PRECOMP_HPP__ +#define __OPENCV_PERF_PRECOMP_HPP__ + +#include +#include +#include +#include + +#endif diff --git a/modules/dnn/samples/.gitignore b/modules/dnn/samples/.gitignore new file mode 100644 index 0000000000..be7186603d --- /dev/null +++ b/modules/dnn/samples/.gitignore @@ -0,0 +1 @@ +*.caffemodel diff --git a/modules/dnn/samples/VGG_VOC0712_SSD_300x300_iter_60000.prototxt b/modules/dnn/samples/VGG_VOC0712_SSD_300x300_iter_60000.prototxt new file mode 100644 index 0000000000..77a2365553 --- /dev/null +++ b/modules/dnn/samples/VGG_VOC0712_SSD_300x300_iter_60000.prototxt @@ -0,0 +1,1546 @@ +name: "VGG_VOC0712_SSD_300x300_deploy" +input: "data" +input_dim: 1 +input_dim: 3 +input_dim: 300 +input_dim: 300 +layer { + name: "conv1_1" + type: "Convolution" + bottom: "data" + top: "conv1_1" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu1_1" + type: "ReLU" + bottom: "conv1_1" + top: "conv1_1" +} +layer { + name: "conv1_2" + type: "Convolution" + bottom: "conv1_1" + top: "conv1_2" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu1_2" + type: "ReLU" + bottom: "conv1_2" + top: "conv1_2" +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1_2" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv2_1" + type: "Convolution" + bottom: "pool1" + top: "conv2_1" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu2_1" + type: "ReLU" + bottom: "conv2_1" + top: "conv2_1" +} +layer { + name: "conv2_2" + type: "Convolution" + bottom: "conv2_1" + top: "conv2_2" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu2_2" + type: "ReLU" + bottom: "conv2_2" + top: "conv2_2" +} +layer { + name: "pool2" + type: "Pooling" + bottom: "conv2_2" + top: "pool2" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv3_1" + type: "Convolution" + bottom: "pool2" + top: "conv3_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu3_1" + type: "ReLU" + bottom: "conv3_1" + top: "conv3_1" +} +layer { + name: "conv3_2" + type: "Convolution" + bottom: "conv3_1" + top: "conv3_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu3_2" + type: "ReLU" + bottom: "conv3_2" + top: "conv3_2" +} +layer { + name: "conv3_3" + type: "Convolution" + bottom: "conv3_2" + top: "conv3_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu3_3" + type: "ReLU" + bottom: "conv3_3" + top: "conv3_3" +} +layer { + name: "pool3" + type: "Pooling" + bottom: "conv3_3" + top: "pool3" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv4_1" + type: "Convolution" + bottom: "pool3" + top: "conv4_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu4_1" + type: "ReLU" + bottom: "conv4_1" + top: "conv4_1" +} +layer { + name: "conv4_2" + type: "Convolution" + bottom: "conv4_1" + top: "conv4_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu4_2" + type: "ReLU" + bottom: "conv4_2" + top: "conv4_2" +} +layer { + name: "conv4_3" + type: "Convolution" + bottom: "conv4_2" + top: "conv4_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu4_3" + type: "ReLU" + bottom: "conv4_3" + top: "conv4_3" +} +layer { + name: "pool4" + type: "Pooling" + bottom: "conv4_3" + top: "pool4" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv5_1" + type: "Convolution" + bottom: "pool4" + top: "conv5_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu5_1" + type: "ReLU" + bottom: "conv5_1" + top: "conv5_1" +} +layer { + name: "conv5_2" + type: "Convolution" + bottom: "conv5_1" + top: "conv5_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu5_2" + type: "ReLU" + bottom: "conv5_2" + top: "conv5_2" +} +layer { + name: "conv5_3" + type: "Convolution" + bottom: "conv5_2" + top: "conv5_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu5_3" + type: "ReLU" + bottom: "conv5_3" + top: "conv5_3" +} +layer { + name: "pool5" + type: "Pooling" + bottom: "conv5_3" + top: "pool5" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "fc6" + type: "Convolution" + bottom: "pool5" + top: "fc6" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 1024 + pad: 6 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + dilation: 6 + } +} +layer { + name: "relu6" + type: "ReLU" + bottom: "fc6" + top: "fc6" +} +layer { + name: "fc7" + type: "Convolution" + bottom: "fc6" + top: "fc7" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 1024 + kernel_size: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "relu7" + type: "ReLU" + bottom: "fc7" + top: "fc7" +} +layer { + name: "conv6_1" + type: "Convolution" + bottom: "fc7" + top: "conv6_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 0 + kernel_size: 1 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv6_1_relu" + type: "ReLU" + bottom: "conv6_1" + top: "conv6_1" +} +layer { + name: "conv6_2" + type: "Convolution" + bottom: "conv6_1" + top: "conv6_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 2 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv6_2_relu" + type: "ReLU" + bottom: "conv6_2" + top: "conv6_2" +} +layer { + name: "conv7_1" + type: "Convolution" + bottom: "conv6_2" + top: "conv7_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 0 + kernel_size: 1 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv7_1_relu" + type: "ReLU" + bottom: "conv7_1" + top: "conv7_1" +} +layer { + name: "conv7_2" + type: "Convolution" + bottom: "conv7_1" + top: "conv7_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 2 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv7_2_relu" + type: "ReLU" + bottom: "conv7_2" + top: "conv7_2" +} +layer { + name: "conv8_1" + type: "Convolution" + bottom: "conv7_2" + top: "conv8_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 0 + kernel_size: 1 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv8_1_relu" + type: "ReLU" + bottom: "conv8_1" + top: "conv8_1" +} +layer { + name: "conv8_2" + type: "Convolution" + bottom: "conv8_1" + top: "conv8_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 2 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv8_2_relu" + type: "ReLU" + bottom: "conv8_2" + top: "conv8_2" +} +layer { + name: "pool6" + type: "Pooling" + bottom: "conv8_2" + top: "pool6" + pooling_param { + pool: AVE + global_pooling: true + } +} +layer { + name: "conv4_3_norm" + type: "NormalizeBBox" + bottom: "conv4_3" + top: "conv4_3_norm" + normalize_bbox_param { + across_spatial: false + scale_filler { + type: "constant" + value: 20 + } + channel_shared: false + } +} +layer { + name: "conv4_3_norm_mbox_loc" + type: "Convolution" + bottom: "conv4_3_norm" + top: "conv4_3_norm_mbox_loc" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 12 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv4_3_norm_mbox_loc_perm" + type: "Permute" + bottom: "conv4_3_norm_mbox_loc" + top: "conv4_3_norm_mbox_loc_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv4_3_norm_mbox_loc_flat" + type: "Flatten" + bottom: "conv4_3_norm_mbox_loc_perm" + top: "conv4_3_norm_mbox_loc_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv4_3_norm_mbox_conf" + type: "Convolution" + bottom: "conv4_3_norm" + top: "conv4_3_norm_mbox_conf" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 63 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv4_3_norm_mbox_conf_perm" + type: "Permute" + bottom: "conv4_3_norm_mbox_conf" + top: "conv4_3_norm_mbox_conf_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv4_3_norm_mbox_conf_flat" + type: "Flatten" + bottom: "conv4_3_norm_mbox_conf_perm" + top: "conv4_3_norm_mbox_conf_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv4_3_norm_mbox_priorbox" + type: "PriorBox" + bottom: "conv4_3_norm" + bottom: "data" + top: "conv4_3_norm_mbox_priorbox" + prior_box_param { + min_size: 30.0 + aspect_ratio: 2 + flip: true + clip: true + variance: 0.1 + variance: 0.1 + variance: 0.2 + variance: 0.2 + } +} +layer { + name: "fc7_mbox_loc" + type: "Convolution" + bottom: "fc7" + top: "fc7_mbox_loc" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 24 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "fc7_mbox_loc_perm" + type: "Permute" + bottom: "fc7_mbox_loc" + top: "fc7_mbox_loc_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "fc7_mbox_loc_flat" + type: "Flatten" + bottom: "fc7_mbox_loc_perm" + top: "fc7_mbox_loc_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "fc7_mbox_conf" + type: "Convolution" + bottom: "fc7" + top: "fc7_mbox_conf" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 126 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "fc7_mbox_conf_perm" + type: "Permute" + bottom: "fc7_mbox_conf" + top: "fc7_mbox_conf_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "fc7_mbox_conf_flat" + type: "Flatten" + bottom: "fc7_mbox_conf_perm" + top: "fc7_mbox_conf_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "fc7_mbox_priorbox" + type: "PriorBox" + bottom: "fc7" + bottom: "data" + top: "fc7_mbox_priorbox" + prior_box_param { + min_size: 60.0 + max_size: 114.0 + aspect_ratio: 2 + aspect_ratio: 3 + flip: true + clip: true + variance: 0.1 + variance: 0.1 + variance: 0.2 + variance: 0.2 + } +} +layer { + name: "conv6_2_mbox_loc" + type: "Convolution" + bottom: "conv6_2" + top: "conv6_2_mbox_loc" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 24 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv6_2_mbox_loc_perm" + type: "Permute" + bottom: "conv6_2_mbox_loc" + top: "conv6_2_mbox_loc_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv6_2_mbox_loc_flat" + type: "Flatten" + bottom: "conv6_2_mbox_loc_perm" + top: "conv6_2_mbox_loc_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv6_2_mbox_conf" + type: "Convolution" + bottom: "conv6_2" + top: "conv6_2_mbox_conf" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 126 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv6_2_mbox_conf_perm" + type: "Permute" + bottom: "conv6_2_mbox_conf" + top: "conv6_2_mbox_conf_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv6_2_mbox_conf_flat" + type: "Flatten" + bottom: "conv6_2_mbox_conf_perm" + top: "conv6_2_mbox_conf_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv6_2_mbox_priorbox" + type: "PriorBox" + bottom: "conv6_2" + bottom: "data" + top: "conv6_2_mbox_priorbox" + prior_box_param { + min_size: 114.0 + max_size: 168.0 + aspect_ratio: 2 + aspect_ratio: 3 + flip: true + clip: true + variance: 0.1 + variance: 0.1 + variance: 0.2 + variance: 0.2 + } +} +layer { + name: "conv7_2_mbox_loc" + type: "Convolution" + bottom: "conv7_2" + top: "conv7_2_mbox_loc" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 24 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv7_2_mbox_loc_perm" + type: "Permute" + bottom: "conv7_2_mbox_loc" + top: "conv7_2_mbox_loc_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv7_2_mbox_loc_flat" + type: "Flatten" + bottom: "conv7_2_mbox_loc_perm" + top: "conv7_2_mbox_loc_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv7_2_mbox_conf" + type: "Convolution" + bottom: "conv7_2" + top: "conv7_2_mbox_conf" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 126 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv7_2_mbox_conf_perm" + type: "Permute" + bottom: "conv7_2_mbox_conf" + top: "conv7_2_mbox_conf_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv7_2_mbox_conf_flat" + type: "Flatten" + bottom: "conv7_2_mbox_conf_perm" + top: "conv7_2_mbox_conf_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv7_2_mbox_priorbox" + type: "PriorBox" + bottom: "conv7_2" + bottom: "data" + top: "conv7_2_mbox_priorbox" + prior_box_param { + min_size: 168.0 + max_size: 222.0 + aspect_ratio: 2 + aspect_ratio: 3 + flip: true + clip: true + variance: 0.1 + variance: 0.1 + variance: 0.2 + variance: 0.2 + } +} +layer { + name: "conv8_2_mbox_loc" + type: "Convolution" + bottom: "conv8_2" + top: "conv8_2_mbox_loc" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 24 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv8_2_mbox_loc_perm" + type: "Permute" + bottom: "conv8_2_mbox_loc" + top: "conv8_2_mbox_loc_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv8_2_mbox_loc_flat" + type: "Flatten" + bottom: "conv8_2_mbox_loc_perm" + top: "conv8_2_mbox_loc_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv8_2_mbox_conf" + type: "Convolution" + bottom: "conv8_2" + top: "conv8_2_mbox_conf" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 126 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv8_2_mbox_conf_perm" + type: "Permute" + bottom: "conv8_2_mbox_conf" + top: "conv8_2_mbox_conf_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "conv8_2_mbox_conf_flat" + type: "Flatten" + bottom: "conv8_2_mbox_conf_perm" + top: "conv8_2_mbox_conf_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "conv8_2_mbox_priorbox" + type: "PriorBox" + bottom: "conv8_2" + bottom: "data" + top: "conv8_2_mbox_priorbox" + prior_box_param { + min_size: 222.0 + max_size: 276.0 + aspect_ratio: 2 + aspect_ratio: 3 + flip: true + clip: true + variance: 0.1 + variance: 0.1 + variance: 0.2 + variance: 0.2 + } +} +layer { + name: "pool6_mbox_loc" + type: "Convolution" + bottom: "pool6" + top: "pool6_mbox_loc" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 24 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "pool6_mbox_loc_perm" + type: "Permute" + bottom: "pool6_mbox_loc" + top: "pool6_mbox_loc_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "pool6_mbox_loc_flat" + type: "Flatten" + bottom: "pool6_mbox_loc_perm" + top: "pool6_mbox_loc_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "pool6_mbox_conf" + type: "Convolution" + bottom: "pool6" + top: "pool6_mbox_conf" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 126 + pad: 1 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "pool6_mbox_conf_perm" + type: "Permute" + bottom: "pool6_mbox_conf" + top: "pool6_mbox_conf_perm" + permute_param { + order: 0 + order: 2 + order: 3 + order: 1 + } +} +layer { + name: "pool6_mbox_conf_flat" + type: "Flatten" + bottom: "pool6_mbox_conf_perm" + top: "pool6_mbox_conf_flat" + flatten_param { + axis: 1 + } +} +layer { + name: "pool6_mbox_priorbox" + type: "PriorBox" + bottom: "pool6" + bottom: "data" + top: "pool6_mbox_priorbox" + prior_box_param { + min_size: 276.0 + max_size: 330.0 + aspect_ratio: 2 + aspect_ratio: 3 + flip: true + clip: true + variance: 0.1 + variance: 0.1 + variance: 0.2 + variance: 0.2 + } +} +layer { + name: "mbox_loc" + type: "Concat" + bottom: "conv4_3_norm_mbox_loc_flat" + bottom: "fc7_mbox_loc_flat" + bottom: "conv6_2_mbox_loc_flat" + bottom: "conv7_2_mbox_loc_flat" + bottom: "conv8_2_mbox_loc_flat" + bottom: "pool6_mbox_loc_flat" + top: "mbox_loc" + concat_param { + axis: 1 + } +} +layer { + name: "mbox_conf" + type: "Concat" + bottom: "conv4_3_norm_mbox_conf_flat" + bottom: "fc7_mbox_conf_flat" + bottom: "conv6_2_mbox_conf_flat" + bottom: "conv7_2_mbox_conf_flat" + bottom: "conv8_2_mbox_conf_flat" + bottom: "pool6_mbox_conf_flat" + top: "mbox_conf" + concat_param { + axis: 1 + } +} +layer { + name: "mbox_priorbox" + type: "Concat" + bottom: "conv4_3_norm_mbox_priorbox" + bottom: "fc7_mbox_priorbox" + bottom: "conv6_2_mbox_priorbox" + bottom: "conv7_2_mbox_priorbox" + bottom: "conv8_2_mbox_priorbox" + bottom: "pool6_mbox_priorbox" + top: "mbox_priorbox" + concat_param { + axis: 2 + } +} +layer { + name: "mbox_conf_reshape" + type: "Reshape" + bottom: "mbox_conf" + top: "mbox_conf_reshape" + reshape_param { + shape { + dim: 0 + dim: -1 + dim: 21 + } + } +} +layer { + name: "mbox_conf_softmax" + type: "Softmax" + bottom: "mbox_conf_reshape" + top: "mbox_conf_softmax" + softmax_param { + axis: 2 + } +} +layer { + name: "mbox_conf_flatten" + type: "Flatten" + bottom: "mbox_conf_softmax" + top: "mbox_conf_flatten" + flatten_param { + axis: 1 + } +} +layer { + name: "detection_out" + type: "DetectionOutput" + bottom: "mbox_loc" + bottom: "mbox_conf_flatten" + bottom: "mbox_priorbox" + top: "detection_out" + include { + phase: TEST + } + detection_output_param { + num_classes: 21 + share_location: true + background_label_id: 0 + nms_threshold: 0.45 + top_k: 400 + code_type: CENTER_SIZE + keep_top_k: 200 + confidence_threshold: 0.01 + } +} diff --git a/modules/dnn/samples/bvlc_googlenet.prototxt b/modules/dnn/samples/bvlc_googlenet.prototxt new file mode 100644 index 0000000000..4648bf26ef --- /dev/null +++ b/modules/dnn/samples/bvlc_googlenet.prototxt @@ -0,0 +1,2156 @@ +name: "GoogleNet" +input: "data" +input_dim: 10 +input_dim: 3 +input_dim: 224 +input_dim: 224 +layer { + name: "conv1/7x7_s2" + type: "Convolution" + bottom: "data" + top: "conv1/7x7_s2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 3 + kernel_size: 7 + stride: 2 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "conv1/relu_7x7" + type: "ReLU" + bottom: "conv1/7x7_s2" + top: "conv1/7x7_s2" +} +layer { + name: "pool1/3x3_s2" + type: "Pooling" + bottom: "conv1/7x7_s2" + top: "pool1/3x3_s2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} +layer { + name: "pool1/norm1" + type: "LRN" + bottom: "pool1/3x3_s2" + top: "pool1/norm1" + lrn_param { + local_size: 5 + alpha: 0.0001 + beta: 0.75 + } +} +layer { + name: "conv2/3x3_reduce" + type: "Convolution" + bottom: "pool1/norm1" + top: "conv2/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "conv2/relu_3x3_reduce" + type: "ReLU" + bottom: "conv2/3x3_reduce" + top: "conv2/3x3_reduce" +} +layer { + name: "conv2/3x3" + type: "Convolution" + bottom: "conv2/3x3_reduce" + top: "conv2/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 192 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "conv2/relu_3x3" + type: "ReLU" + bottom: "conv2/3x3" + top: "conv2/3x3" +} +layer { + name: "conv2/norm2" + type: "LRN" + bottom: "conv2/3x3" + top: "conv2/norm2" + lrn_param { + local_size: 5 + alpha: 0.0001 + beta: 0.75 + } +} +layer { + name: "pool2/3x3_s2" + type: "Pooling" + bottom: "conv2/norm2" + top: "pool2/3x3_s2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} +layer { + name: "inception_3a/1x1" + type: "Convolution" + bottom: "pool2/3x3_s2" + top: "inception_3a/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3a/relu_1x1" + type: "ReLU" + bottom: "inception_3a/1x1" + top: "inception_3a/1x1" +} +layer { + name: "inception_3a/3x3_reduce" + type: "Convolution" + bottom: "pool2/3x3_s2" + top: "inception_3a/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 96 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3a/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_3a/3x3_reduce" + top: "inception_3a/3x3_reduce" +} +layer { + name: "inception_3a/3x3" + type: "Convolution" + bottom: "inception_3a/3x3_reduce" + top: "inception_3a/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3a/relu_3x3" + type: "ReLU" + bottom: "inception_3a/3x3" + top: "inception_3a/3x3" +} +layer { + name: "inception_3a/5x5_reduce" + type: "Convolution" + bottom: "pool2/3x3_s2" + top: "inception_3a/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 16 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3a/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_3a/5x5_reduce" + top: "inception_3a/5x5_reduce" +} +layer { + name: "inception_3a/5x5" + type: "Convolution" + bottom: "inception_3a/5x5_reduce" + top: "inception_3a/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 32 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3a/relu_5x5" + type: "ReLU" + bottom: "inception_3a/5x5" + top: "inception_3a/5x5" +} +layer { + name: "inception_3a/pool" + type: "Pooling" + bottom: "pool2/3x3_s2" + top: "inception_3a/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_3a/pool_proj" + type: "Convolution" + bottom: "inception_3a/pool" + top: "inception_3a/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 32 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3a/relu_pool_proj" + type: "ReLU" + bottom: "inception_3a/pool_proj" + top: "inception_3a/pool_proj" +} +layer { + name: "inception_3a/output" + type: "Concat" + bottom: "inception_3a/1x1" + bottom: "inception_3a/3x3" + bottom: "inception_3a/5x5" + bottom: "inception_3a/pool_proj" + top: "inception_3a/output" +} +layer { + name: "inception_3b/1x1" + type: "Convolution" + bottom: "inception_3a/output" + top: "inception_3b/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3b/relu_1x1" + type: "ReLU" + bottom: "inception_3b/1x1" + top: "inception_3b/1x1" +} +layer { + name: "inception_3b/3x3_reduce" + type: "Convolution" + bottom: "inception_3a/output" + top: "inception_3b/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3b/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_3b/3x3_reduce" + top: "inception_3b/3x3_reduce" +} +layer { + name: "inception_3b/3x3" + type: "Convolution" + bottom: "inception_3b/3x3_reduce" + top: "inception_3b/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 192 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3b/relu_3x3" + type: "ReLU" + bottom: "inception_3b/3x3" + top: "inception_3b/3x3" +} +layer { + name: "inception_3b/5x5_reduce" + type: "Convolution" + bottom: "inception_3a/output" + top: "inception_3b/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 32 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3b/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_3b/5x5_reduce" + top: "inception_3b/5x5_reduce" +} +layer { + name: "inception_3b/5x5" + type: "Convolution" + bottom: "inception_3b/5x5_reduce" + top: "inception_3b/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 96 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3b/relu_5x5" + type: "ReLU" + bottom: "inception_3b/5x5" + top: "inception_3b/5x5" +} +layer { + name: "inception_3b/pool" + type: "Pooling" + bottom: "inception_3a/output" + top: "inception_3b/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_3b/pool_proj" + type: "Convolution" + bottom: "inception_3b/pool" + top: "inception_3b/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_3b/relu_pool_proj" + type: "ReLU" + bottom: "inception_3b/pool_proj" + top: "inception_3b/pool_proj" +} +layer { + name: "inception_3b/output" + type: "Concat" + bottom: "inception_3b/1x1" + bottom: "inception_3b/3x3" + bottom: "inception_3b/5x5" + bottom: "inception_3b/pool_proj" + top: "inception_3b/output" +} +layer { + name: "pool3/3x3_s2" + type: "Pooling" + bottom: "inception_3b/output" + top: "pool3/3x3_s2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} +layer { + name: "inception_4a/1x1" + type: "Convolution" + bottom: "pool3/3x3_s2" + top: "inception_4a/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 192 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4a/relu_1x1" + type: "ReLU" + bottom: "inception_4a/1x1" + top: "inception_4a/1x1" +} +layer { + name: "inception_4a/3x3_reduce" + type: "Convolution" + bottom: "pool3/3x3_s2" + top: "inception_4a/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 96 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4a/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_4a/3x3_reduce" + top: "inception_4a/3x3_reduce" +} +layer { + name: "inception_4a/3x3" + type: "Convolution" + bottom: "inception_4a/3x3_reduce" + top: "inception_4a/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 208 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4a/relu_3x3" + type: "ReLU" + bottom: "inception_4a/3x3" + top: "inception_4a/3x3" +} +layer { + name: "inception_4a/5x5_reduce" + type: "Convolution" + bottom: "pool3/3x3_s2" + top: "inception_4a/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 16 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4a/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_4a/5x5_reduce" + top: "inception_4a/5x5_reduce" +} +layer { + name: "inception_4a/5x5" + type: "Convolution" + bottom: "inception_4a/5x5_reduce" + top: "inception_4a/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 48 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4a/relu_5x5" + type: "ReLU" + bottom: "inception_4a/5x5" + top: "inception_4a/5x5" +} +layer { + name: "inception_4a/pool" + type: "Pooling" + bottom: "pool3/3x3_s2" + top: "inception_4a/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_4a/pool_proj" + type: "Convolution" + bottom: "inception_4a/pool" + top: "inception_4a/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4a/relu_pool_proj" + type: "ReLU" + bottom: "inception_4a/pool_proj" + top: "inception_4a/pool_proj" +} +layer { + name: "inception_4a/output" + type: "Concat" + bottom: "inception_4a/1x1" + bottom: "inception_4a/3x3" + bottom: "inception_4a/5x5" + bottom: "inception_4a/pool_proj" + top: "inception_4a/output" +} +layer { + name: "inception_4b/1x1" + type: "Convolution" + bottom: "inception_4a/output" + top: "inception_4b/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 160 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4b/relu_1x1" + type: "ReLU" + bottom: "inception_4b/1x1" + top: "inception_4b/1x1" +} +layer { + name: "inception_4b/3x3_reduce" + type: "Convolution" + bottom: "inception_4a/output" + top: "inception_4b/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 112 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4b/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_4b/3x3_reduce" + top: "inception_4b/3x3_reduce" +} +layer { + name: "inception_4b/3x3" + type: "Convolution" + bottom: "inception_4b/3x3_reduce" + top: "inception_4b/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 224 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4b/relu_3x3" + type: "ReLU" + bottom: "inception_4b/3x3" + top: "inception_4b/3x3" +} +layer { + name: "inception_4b/5x5_reduce" + type: "Convolution" + bottom: "inception_4a/output" + top: "inception_4b/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 24 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4b/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_4b/5x5_reduce" + top: "inception_4b/5x5_reduce" +} +layer { + name: "inception_4b/5x5" + type: "Convolution" + bottom: "inception_4b/5x5_reduce" + top: "inception_4b/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4b/relu_5x5" + type: "ReLU" + bottom: "inception_4b/5x5" + top: "inception_4b/5x5" +} +layer { + name: "inception_4b/pool" + type: "Pooling" + bottom: "inception_4a/output" + top: "inception_4b/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_4b/pool_proj" + type: "Convolution" + bottom: "inception_4b/pool" + top: "inception_4b/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4b/relu_pool_proj" + type: "ReLU" + bottom: "inception_4b/pool_proj" + top: "inception_4b/pool_proj" +} +layer { + name: "inception_4b/output" + type: "Concat" + bottom: "inception_4b/1x1" + bottom: "inception_4b/3x3" + bottom: "inception_4b/5x5" + bottom: "inception_4b/pool_proj" + top: "inception_4b/output" +} +layer { + name: "inception_4c/1x1" + type: "Convolution" + bottom: "inception_4b/output" + top: "inception_4c/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4c/relu_1x1" + type: "ReLU" + bottom: "inception_4c/1x1" + top: "inception_4c/1x1" +} +layer { + name: "inception_4c/3x3_reduce" + type: "Convolution" + bottom: "inception_4b/output" + top: "inception_4c/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4c/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_4c/3x3_reduce" + top: "inception_4c/3x3_reduce" +} +layer { + name: "inception_4c/3x3" + type: "Convolution" + bottom: "inception_4c/3x3_reduce" + top: "inception_4c/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4c/relu_3x3" + type: "ReLU" + bottom: "inception_4c/3x3" + top: "inception_4c/3x3" +} +layer { + name: "inception_4c/5x5_reduce" + type: "Convolution" + bottom: "inception_4b/output" + top: "inception_4c/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 24 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4c/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_4c/5x5_reduce" + top: "inception_4c/5x5_reduce" +} +layer { + name: "inception_4c/5x5" + type: "Convolution" + bottom: "inception_4c/5x5_reduce" + top: "inception_4c/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4c/relu_5x5" + type: "ReLU" + bottom: "inception_4c/5x5" + top: "inception_4c/5x5" +} +layer { + name: "inception_4c/pool" + type: "Pooling" + bottom: "inception_4b/output" + top: "inception_4c/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_4c/pool_proj" + type: "Convolution" + bottom: "inception_4c/pool" + top: "inception_4c/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4c/relu_pool_proj" + type: "ReLU" + bottom: "inception_4c/pool_proj" + top: "inception_4c/pool_proj" +} +layer { + name: "inception_4c/output" + type: "Concat" + bottom: "inception_4c/1x1" + bottom: "inception_4c/3x3" + bottom: "inception_4c/5x5" + bottom: "inception_4c/pool_proj" + top: "inception_4c/output" +} +layer { + name: "inception_4d/1x1" + type: "Convolution" + bottom: "inception_4c/output" + top: "inception_4d/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 112 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4d/relu_1x1" + type: "ReLU" + bottom: "inception_4d/1x1" + top: "inception_4d/1x1" +} +layer { + name: "inception_4d/3x3_reduce" + type: "Convolution" + bottom: "inception_4c/output" + top: "inception_4d/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 144 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4d/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_4d/3x3_reduce" + top: "inception_4d/3x3_reduce" +} +layer { + name: "inception_4d/3x3" + type: "Convolution" + bottom: "inception_4d/3x3_reduce" + top: "inception_4d/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 288 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4d/relu_3x3" + type: "ReLU" + bottom: "inception_4d/3x3" + top: "inception_4d/3x3" +} +layer { + name: "inception_4d/5x5_reduce" + type: "Convolution" + bottom: "inception_4c/output" + top: "inception_4d/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 32 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4d/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_4d/5x5_reduce" + top: "inception_4d/5x5_reduce" +} +layer { + name: "inception_4d/5x5" + type: "Convolution" + bottom: "inception_4d/5x5_reduce" + top: "inception_4d/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4d/relu_5x5" + type: "ReLU" + bottom: "inception_4d/5x5" + top: "inception_4d/5x5" +} +layer { + name: "inception_4d/pool" + type: "Pooling" + bottom: "inception_4c/output" + top: "inception_4d/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_4d/pool_proj" + type: "Convolution" + bottom: "inception_4d/pool" + top: "inception_4d/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4d/relu_pool_proj" + type: "ReLU" + bottom: "inception_4d/pool_proj" + top: "inception_4d/pool_proj" +} +layer { + name: "inception_4d/output" + type: "Concat" + bottom: "inception_4d/1x1" + bottom: "inception_4d/3x3" + bottom: "inception_4d/5x5" + bottom: "inception_4d/pool_proj" + top: "inception_4d/output" +} +layer { + name: "inception_4e/1x1" + type: "Convolution" + bottom: "inception_4d/output" + top: "inception_4e/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4e/relu_1x1" + type: "ReLU" + bottom: "inception_4e/1x1" + top: "inception_4e/1x1" +} +layer { + name: "inception_4e/3x3_reduce" + type: "Convolution" + bottom: "inception_4d/output" + top: "inception_4e/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 160 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4e/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_4e/3x3_reduce" + top: "inception_4e/3x3_reduce" +} +layer { + name: "inception_4e/3x3" + type: "Convolution" + bottom: "inception_4e/3x3_reduce" + top: "inception_4e/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 320 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4e/relu_3x3" + type: "ReLU" + bottom: "inception_4e/3x3" + top: "inception_4e/3x3" +} +layer { + name: "inception_4e/5x5_reduce" + type: "Convolution" + bottom: "inception_4d/output" + top: "inception_4e/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 32 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4e/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_4e/5x5_reduce" + top: "inception_4e/5x5_reduce" +} +layer { + name: "inception_4e/5x5" + type: "Convolution" + bottom: "inception_4e/5x5_reduce" + top: "inception_4e/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4e/relu_5x5" + type: "ReLU" + bottom: "inception_4e/5x5" + top: "inception_4e/5x5" +} +layer { + name: "inception_4e/pool" + type: "Pooling" + bottom: "inception_4d/output" + top: "inception_4e/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_4e/pool_proj" + type: "Convolution" + bottom: "inception_4e/pool" + top: "inception_4e/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_4e/relu_pool_proj" + type: "ReLU" + bottom: "inception_4e/pool_proj" + top: "inception_4e/pool_proj" +} +layer { + name: "inception_4e/output" + type: "Concat" + bottom: "inception_4e/1x1" + bottom: "inception_4e/3x3" + bottom: "inception_4e/5x5" + bottom: "inception_4e/pool_proj" + top: "inception_4e/output" +} +layer { + name: "pool4/3x3_s2" + type: "Pooling" + bottom: "inception_4e/output" + top: "pool4/3x3_s2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} +layer { + name: "inception_5a/1x1" + type: "Convolution" + bottom: "pool4/3x3_s2" + top: "inception_5a/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5a/relu_1x1" + type: "ReLU" + bottom: "inception_5a/1x1" + top: "inception_5a/1x1" +} +layer { + name: "inception_5a/3x3_reduce" + type: "Convolution" + bottom: "pool4/3x3_s2" + top: "inception_5a/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 160 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5a/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_5a/3x3_reduce" + top: "inception_5a/3x3_reduce" +} +layer { + name: "inception_5a/3x3" + type: "Convolution" + bottom: "inception_5a/3x3_reduce" + top: "inception_5a/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 320 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5a/relu_3x3" + type: "ReLU" + bottom: "inception_5a/3x3" + top: "inception_5a/3x3" +} +layer { + name: "inception_5a/5x5_reduce" + type: "Convolution" + bottom: "pool4/3x3_s2" + top: "inception_5a/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 32 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5a/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_5a/5x5_reduce" + top: "inception_5a/5x5_reduce" +} +layer { + name: "inception_5a/5x5" + type: "Convolution" + bottom: "inception_5a/5x5_reduce" + top: "inception_5a/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5a/relu_5x5" + type: "ReLU" + bottom: "inception_5a/5x5" + top: "inception_5a/5x5" +} +layer { + name: "inception_5a/pool" + type: "Pooling" + bottom: "pool4/3x3_s2" + top: "inception_5a/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_5a/pool_proj" + type: "Convolution" + bottom: "inception_5a/pool" + top: "inception_5a/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5a/relu_pool_proj" + type: "ReLU" + bottom: "inception_5a/pool_proj" + top: "inception_5a/pool_proj" +} +layer { + name: "inception_5a/output" + type: "Concat" + bottom: "inception_5a/1x1" + bottom: "inception_5a/3x3" + bottom: "inception_5a/5x5" + bottom: "inception_5a/pool_proj" + top: "inception_5a/output" +} +layer { + name: "inception_5b/1x1" + type: "Convolution" + bottom: "inception_5a/output" + top: "inception_5b/1x1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 384 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5b/relu_1x1" + type: "ReLU" + bottom: "inception_5b/1x1" + top: "inception_5b/1x1" +} +layer { + name: "inception_5b/3x3_reduce" + type: "Convolution" + bottom: "inception_5a/output" + top: "inception_5b/3x3_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 192 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.09 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5b/relu_3x3_reduce" + type: "ReLU" + bottom: "inception_5b/3x3_reduce" + top: "inception_5b/3x3_reduce" +} +layer { + name: "inception_5b/3x3" + type: "Convolution" + bottom: "inception_5b/3x3_reduce" + top: "inception_5b/3x3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 384 + pad: 1 + kernel_size: 3 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5b/relu_3x3" + type: "ReLU" + bottom: "inception_5b/3x3" + top: "inception_5b/3x3" +} +layer { + name: "inception_5b/5x5_reduce" + type: "Convolution" + bottom: "inception_5a/output" + top: "inception_5b/5x5_reduce" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 48 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.2 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5b/relu_5x5_reduce" + type: "ReLU" + bottom: "inception_5b/5x5_reduce" + top: "inception_5b/5x5_reduce" +} +layer { + name: "inception_5b/5x5" + type: "Convolution" + bottom: "inception_5b/5x5_reduce" + top: "inception_5b/5x5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 2 + kernel_size: 5 + weight_filler { + type: "xavier" + std: 0.03 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5b/relu_5x5" + type: "ReLU" + bottom: "inception_5b/5x5" + top: "inception_5b/5x5" +} +layer { + name: "inception_5b/pool" + type: "Pooling" + bottom: "inception_5a/output" + top: "inception_5b/pool" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 1 + pad: 1 + } +} +layer { + name: "inception_5b/pool_proj" + type: "Convolution" + bottom: "inception_5b/pool" + top: "inception_5b/pool_proj" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + kernel_size: 1 + weight_filler { + type: "xavier" + std: 0.1 + } + bias_filler { + type: "constant" + value: 0.2 + } + } +} +layer { + name: "inception_5b/relu_pool_proj" + type: "ReLU" + bottom: "inception_5b/pool_proj" + top: "inception_5b/pool_proj" +} +layer { + name: "inception_5b/output" + type: "Concat" + bottom: "inception_5b/1x1" + bottom: "inception_5b/3x3" + bottom: "inception_5b/5x5" + bottom: "inception_5b/pool_proj" + top: "inception_5b/output" +} +layer { + name: "pool5/7x7_s1" + type: "Pooling" + bottom: "inception_5b/output" + top: "pool5/7x7_s1" + pooling_param { + pool: AVE + kernel_size: 7 + stride: 1 + } +} +layer { + name: "pool5/drop_7x7_s1" + type: "Dropout" + bottom: "pool5/7x7_s1" + top: "pool5/7x7_s1" + dropout_param { + dropout_ratio: 0.4 + } +} +layer { + name: "loss3/classifier" + type: "InnerProduct" + bottom: "pool5/7x7_s1" + top: "loss3/classifier" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + inner_product_param { + num_output: 1000 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prob" + type: "Softmax" + bottom: "loss3/classifier" + top: "prob" +} diff --git a/modules/dnn/samples/caffe_googlenet.cpp b/modules/dnn/samples/caffe_googlenet.cpp new file mode 100644 index 0000000000..59579863f3 --- /dev/null +++ b/modules/dnn/samples/caffe_googlenet.cpp @@ -0,0 +1,143 @@ +/**M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ +#include +#include +#include +using namespace cv; +using namespace cv::dnn; + +#include +#include +#include +using namespace std; + +/* Find best class for the blob (i. e. class with maximal probability) */ +void getMaxClass(const Mat &probBlob, int *classId, double *classProb) +{ + Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix + Point classNumber; + + minMaxLoc(probMat, NULL, classProb, NULL, &classNumber); + *classId = classNumber.x; +} + +std::vector readClassNames(const char *filename = "synset_words.txt") +{ + std::vector classNames; + + std::ifstream fp(filename); + if (!fp.is_open()) + { + std::cerr << "File with classes labels not found: " << filename << std::endl; + exit(-1); + } + + std::string name; + while (!fp.eof()) + { + std::getline(fp, name); + if (name.length()) + classNames.push_back( name.substr(name.find(' ')+1) ); + } + + fp.close(); + return classNames; +} + +int main(int argc, char **argv) +{ + cv::dnn::initModule(); //Required if OpenCV is built as static libs + + String modelTxt = "bvlc_googlenet.prototxt"; + String modelBin = "bvlc_googlenet.caffemodel"; + String imageFile = (argc > 1) ? argv[1] : "space_shuttle.jpg"; + + //! [Read and initialize network] + Net net = dnn::readNetFromCaffe(modelTxt, modelBin); + //! [Read and initialize network] + + //! [Check that network was read successfully] + if (net.empty()) + { + std::cerr << "Can't load network by using the following files: " << std::endl; + std::cerr << "prototxt: " << modelTxt << std::endl; + std::cerr << "caffemodel: " << modelBin << std::endl; + std::cerr << "bvlc_googlenet.caffemodel can be downloaded here:" << std::endl; + std::cerr << "http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel" << std::endl; + exit(-1); + } + //! [Check that network was read successfully] + + //! [Prepare blob] + Mat img = imread(imageFile); + if (img.empty()) + { + std::cerr << "Can't read image from the file: " << imageFile << std::endl; + exit(-1); + } + + //GoogLeNet accepts only 224x224 RGB-images + Mat inputBlob = blobFromImage(img, 1, Size(224, 224), + Scalar(104, 117, 123)); //Convert Mat to batch of images + //! [Prepare blob] + + //! [Set input blob] + net.setInput(inputBlob, "data"); //set the network input + //! [Set input blob] + + //! [Make forward pass] + Mat prob = net.forward("prob"); //compute output + //! [Make forward pass] + + //! [Gather output] + int classId; + double classProb; + getMaxClass(prob, &classId, &classProb);//find the best class + //! [Gather output] + + //! [Print results] + std::vector classNames = readClassNames(); + std::cout << "Best class: #" << classId << " '" << classNames.at(classId) << "'" << std::endl; + std::cout << "Probability: " << classProb * 100 << "%" << std::endl; + //! [Print results] + + return 0; +} //main diff --git a/modules/dnn/samples/enet-classes.txt b/modules/dnn/samples/enet-classes.txt new file mode 100644 index 0000000000..303bf6f4c5 --- /dev/null +++ b/modules/dnn/samples/enet-classes.txt @@ -0,0 +1,20 @@ +Unlabeled 0 0 0 +Road 128 64 128 +Sidewalk 244 35 232 +Building 70 70 70 +Wall 102 102 156 +Fence 190 153 153 +Pole 153 153 153 +TrafficLight 250 170 30 +TrafficSign 220 220 0 +Vegetation 107 142 35 +Terrain 152 251 152 +Sky 70 130 180 +Person 220 20 60 +Rider 255 0 0 +Car 0 0 142 +Truck 0 0 70 +Bus 0 60 100 +Train 0 80 100 +Motorcycle 0 0 230 +Bicycle 119 11 32 \ No newline at end of file diff --git a/modules/dnn/samples/fcn32s-heavy-pascal.prototxt b/modules/dnn/samples/fcn32s-heavy-pascal.prototxt new file mode 100644 index 0000000000..7b5a0c55ba --- /dev/null +++ b/modules/dnn/samples/fcn32s-heavy-pascal.prototxt @@ -0,0 +1,502 @@ +# +# This prototxt is based on voc-fcn32s/val.prototxt file from +# https://github.com/shelhamer/fcn.berkeleyvision.org, which is distributed under +# Caffe (BSD) license: +# http://caffe.berkeleyvision.org/model_zoo.html#bvlc-model-license +# +name: "voc-fcn32s" +input: "data" +input_dim: 1 +input_dim: 3 +input_dim: 500 +input_dim: 500 +layer { + name: "conv1_1" + type: "Convolution" + bottom: "data" + top: "conv1_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 100 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu1_1" + type: "ReLU" + bottom: "conv1_1" + top: "conv1_1" +} +layer { + name: "conv1_2" + type: "Convolution" + bottom: "conv1_1" + top: "conv1_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu1_2" + type: "ReLU" + bottom: "conv1_2" + top: "conv1_2" +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1_2" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv2_1" + type: "Convolution" + bottom: "pool1" + top: "conv2_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu2_1" + type: "ReLU" + bottom: "conv2_1" + top: "conv2_1" +} +layer { + name: "conv2_2" + type: "Convolution" + bottom: "conv2_1" + top: "conv2_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu2_2" + type: "ReLU" + bottom: "conv2_2" + top: "conv2_2" +} +layer { + name: "pool2" + type: "Pooling" + bottom: "conv2_2" + top: "pool2" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv3_1" + type: "Convolution" + bottom: "pool2" + top: "conv3_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu3_1" + type: "ReLU" + bottom: "conv3_1" + top: "conv3_1" +} +layer { + name: "conv3_2" + type: "Convolution" + bottom: "conv3_1" + top: "conv3_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu3_2" + type: "ReLU" + bottom: "conv3_2" + top: "conv3_2" +} +layer { + name: "conv3_3" + type: "Convolution" + bottom: "conv3_2" + top: "conv3_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu3_3" + type: "ReLU" + bottom: "conv3_3" + top: "conv3_3" +} +layer { + name: "pool3" + type: "Pooling" + bottom: "conv3_3" + top: "pool3" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv4_1" + type: "Convolution" + bottom: "pool3" + top: "conv4_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu4_1" + type: "ReLU" + bottom: "conv4_1" + top: "conv4_1" +} +layer { + name: "conv4_2" + type: "Convolution" + bottom: "conv4_1" + top: "conv4_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu4_2" + type: "ReLU" + bottom: "conv4_2" + top: "conv4_2" +} +layer { + name: "conv4_3" + type: "Convolution" + bottom: "conv4_2" + top: "conv4_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu4_3" + type: "ReLU" + bottom: "conv4_3" + top: "conv4_3" +} +layer { + name: "pool4" + type: "Pooling" + bottom: "conv4_3" + top: "pool4" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv5_1" + type: "Convolution" + bottom: "pool4" + top: "conv5_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu5_1" + type: "ReLU" + bottom: "conv5_1" + top: "conv5_1" +} +layer { + name: "conv5_2" + type: "Convolution" + bottom: "conv5_1" + top: "conv5_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu5_2" + type: "ReLU" + bottom: "conv5_2" + top: "conv5_2" +} +layer { + name: "conv5_3" + type: "Convolution" + bottom: "conv5_2" + top: "conv5_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu5_3" + type: "ReLU" + bottom: "conv5_3" + top: "conv5_3" +} +layer { + name: "pool5" + type: "Pooling" + bottom: "conv5_3" + top: "pool5" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "fc6" + type: "Convolution" + bottom: "pool5" + top: "fc6" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 4096 + pad: 0 + kernel_size: 7 + stride: 1 + } +} +layer { + name: "relu6" + type: "ReLU" + bottom: "fc6" + top: "fc6" +} +layer { + name: "fc7" + type: "Convolution" + bottom: "fc6" + top: "fc7" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 4096 + pad: 0 + kernel_size: 1 + stride: 1 + } +} +layer { + name: "relu7" + type: "ReLU" + bottom: "fc7" + top: "fc7" +} +layer { + name: "score_fr" + type: "Convolution" + bottom: "fc7" + top: "score_fr" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 21 + pad: 0 + kernel_size: 1 + } +} +layer { + name: "upscore" + type: "Deconvolution" + bottom: "score_fr" + top: "upscore" + param { + lr_mult: 0 + } + convolution_param { + num_output: 21 + bias_term: false + kernel_size: 64 + stride: 32 + } +} +layer { + name: "score" + type: "Crop" + bottom: "upscore" + bottom: "data" + top: "score" + crop_param { + axis: 2 + offset: 19 + } +} diff --git a/modules/dnn/samples/fcn8s-heavy-pascal.prototxt b/modules/dnn/samples/fcn8s-heavy-pascal.prototxt new file mode 100644 index 0000000000..426b40f815 --- /dev/null +++ b/modules/dnn/samples/fcn8s-heavy-pascal.prototxt @@ -0,0 +1,612 @@ +# +# This prototxt is based on voc-fcn8s/val.prototxt file from +# https://github.com/shelhamer/fcn.berkeleyvision.org, which is distributed under +# Caffe (BSD) license: +# http://caffe.berkeleyvision.org/model_zoo.html#bvlc-model-license +# +name: "voc-fcn8s" +input: "data" +input_dim: 1 +input_dim: 3 +input_dim: 500 +input_dim: 500 +layer { + name: "conv1_1" + type: "Convolution" + bottom: "data" + top: "conv1_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 100 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu1_1" + type: "ReLU" + bottom: "conv1_1" + top: "conv1_1" +} +layer { + name: "conv1_2" + type: "Convolution" + bottom: "conv1_1" + top: "conv1_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 64 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu1_2" + type: "ReLU" + bottom: "conv1_2" + top: "conv1_2" +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1_2" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv2_1" + type: "Convolution" + bottom: "pool1" + top: "conv2_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu2_1" + type: "ReLU" + bottom: "conv2_1" + top: "conv2_1" +} +layer { + name: "conv2_2" + type: "Convolution" + bottom: "conv2_1" + top: "conv2_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 128 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu2_2" + type: "ReLU" + bottom: "conv2_2" + top: "conv2_2" +} +layer { + name: "pool2" + type: "Pooling" + bottom: "conv2_2" + top: "pool2" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv3_1" + type: "Convolution" + bottom: "pool2" + top: "conv3_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu3_1" + type: "ReLU" + bottom: "conv3_1" + top: "conv3_1" +} +layer { + name: "conv3_2" + type: "Convolution" + bottom: "conv3_1" + top: "conv3_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu3_2" + type: "ReLU" + bottom: "conv3_2" + top: "conv3_2" +} +layer { + name: "conv3_3" + type: "Convolution" + bottom: "conv3_2" + top: "conv3_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 256 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu3_3" + type: "ReLU" + bottom: "conv3_3" + top: "conv3_3" +} +layer { + name: "pool3" + type: "Pooling" + bottom: "conv3_3" + top: "pool3" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv4_1" + type: "Convolution" + bottom: "pool3" + top: "conv4_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu4_1" + type: "ReLU" + bottom: "conv4_1" + top: "conv4_1" +} +layer { + name: "conv4_2" + type: "Convolution" + bottom: "conv4_1" + top: "conv4_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu4_2" + type: "ReLU" + bottom: "conv4_2" + top: "conv4_2" +} +layer { + name: "conv4_3" + type: "Convolution" + bottom: "conv4_2" + top: "conv4_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu4_3" + type: "ReLU" + bottom: "conv4_3" + top: "conv4_3" +} +layer { + name: "pool4" + type: "Pooling" + bottom: "conv4_3" + top: "pool4" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv5_1" + type: "Convolution" + bottom: "pool4" + top: "conv5_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu5_1" + type: "ReLU" + bottom: "conv5_1" + top: "conv5_1" +} +layer { + name: "conv5_2" + type: "Convolution" + bottom: "conv5_1" + top: "conv5_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu5_2" + type: "ReLU" + bottom: "conv5_2" + top: "conv5_2" +} +layer { + name: "conv5_3" + type: "Convolution" + bottom: "conv5_2" + top: "conv5_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 512 + pad: 1 + kernel_size: 3 + stride: 1 + } +} +layer { + name: "relu5_3" + type: "ReLU" + bottom: "conv5_3" + top: "conv5_3" +} +layer { + name: "pool5" + type: "Pooling" + bottom: "conv5_3" + top: "pool5" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "fc6" + type: "Convolution" + bottom: "pool5" + top: "fc6" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 4096 + pad: 0 + kernel_size: 7 + stride: 1 + } +} +layer { + name: "relu6" + type: "ReLU" + bottom: "fc6" + top: "fc6" +} +layer { + name: "fc7" + type: "Convolution" + bottom: "fc6" + top: "fc7" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 4096 + pad: 0 + kernel_size: 1 + stride: 1 + } +} +layer { + name: "relu7" + type: "ReLU" + bottom: "fc7" + top: "fc7" +} +layer { + name: "score_fr" + type: "Convolution" + bottom: "fc7" + top: "score_fr" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 21 + pad: 0 + kernel_size: 1 + } +} +layer { + name: "upscore2" + type: "Deconvolution" + bottom: "score_fr" + top: "upscore2" + param { + lr_mult: 0 + } + convolution_param { + num_output: 21 + bias_term: false + kernel_size: 4 + stride: 2 + } +} +layer { + name: "score_pool4" + type: "Convolution" + bottom: "pool4" + top: "score_pool4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 21 + pad: 0 + kernel_size: 1 + } +} +layer { + name: "score_pool4c" + type: "Crop" + bottom: "score_pool4" + bottom: "upscore2" + top: "score_pool4c" + crop_param { + axis: 2 + offset: 5 + } +} +layer { + name: "fuse_pool4" + type: "Eltwise" + bottom: "upscore2" + bottom: "score_pool4c" + top: "fuse_pool4" + eltwise_param { + operation: SUM + } +} +layer { + name: "upscore_pool4" + type: "Deconvolution" + bottom: "fuse_pool4" + top: "upscore_pool4" + param { + lr_mult: 0 + } + convolution_param { + num_output: 21 + bias_term: false + kernel_size: 4 + stride: 2 + } +} +layer { + name: "score_pool3" + type: "Convolution" + bottom: "pool3" + top: "score_pool3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 21 + pad: 0 + kernel_size: 1 + } +} +layer { + name: "score_pool3c" + type: "Crop" + bottom: "score_pool3" + bottom: "upscore_pool4" + top: "score_pool3c" + crop_param { + axis: 2 + offset: 9 + } +} +layer { + name: "fuse_pool3" + type: "Eltwise" + bottom: "upscore_pool4" + bottom: "score_pool3c" + top: "fuse_pool3" + eltwise_param { + operation: SUM + } +} +layer { + name: "upscore8" + type: "Deconvolution" + bottom: "fuse_pool3" + top: "upscore8" + param { + lr_mult: 0 + } + convolution_param { + num_output: 21 + bias_term: false + kernel_size: 16 + stride: 8 + } +} +layer { + name: "score" + type: "Crop" + bottom: "upscore8" + bottom: "data" + top: "score" + crop_param { + axis: 2 + offset: 31 + } +} diff --git a/modules/dnn/samples/fcn_semsegm.cpp b/modules/dnn/samples/fcn_semsegm.cpp new file mode 100644 index 0000000000..6706050743 --- /dev/null +++ b/modules/dnn/samples/fcn_semsegm.cpp @@ -0,0 +1,154 @@ +#include +#include +#include +using namespace cv; +using namespace cv::dnn; + +#include +#include +#include +using namespace std; + +static const string fcnType = "fcn8s"; + +static vector readColors(const string &filename = "pascal-classes.txt") +{ + vector colors; + + ifstream fp(filename.c_str()); + if (!fp.is_open()) + { + cerr << "File with colors not found: " << filename << endl; + exit(-1); + } + + string line; + while (!fp.eof()) + { + getline(fp, line); + if (line.length()) + { + stringstream ss(line); + + string name; ss >> name; + int temp; + cv::Vec3b color; + ss >> temp; color[0] = temp; + ss >> temp; color[1] = temp; + ss >> temp; color[2] = temp; + colors.push_back(color); + } + } + + fp.close(); + return colors; +} + +static void colorizeSegmentation(const Mat &score, const vector &colors, cv::Mat &segm) +{ + const int rows = score.size[2]; + const int cols = score.size[3]; + const int chns = score.size[1]; + + cv::Mat maxCl(rows, cols, CV_8UC1); + cv::Mat maxVal(rows, cols, CV_32FC1); + for (int ch = 0; ch < chns; ch++) + { + for (int row = 0; row < rows; row++) + { + const float *ptrScore = score.ptr(0, ch, row); + uchar *ptrMaxCl = maxCl.ptr(row); + float *ptrMaxVal = maxVal.ptr(row); + for (int col = 0; col < cols; col++) + { + if (ptrScore[col] > ptrMaxVal[col]) + { + ptrMaxVal[col] = ptrScore[col]; + ptrMaxCl[col] = ch; + } + } + } + } + + segm.create(rows, cols, CV_8UC3); + for (int row = 0; row < rows; row++) + { + const uchar *ptrMaxCl = maxCl.ptr(row); + cv::Vec3b *ptrSegm = segm.ptr(row); + for (int col = 0; col < cols; col++) + { + ptrSegm[col] = colors[ptrMaxCl[col]]; + } + } + +} + +int main(int argc, char **argv) +{ + cv::dnn::initModule(); //Required if OpenCV is built as static libs + + String modelTxt = fcnType + "-heavy-pascal.prototxt"; + String modelBin = fcnType + "-heavy-pascal.caffemodel"; + String imageFile = (argc > 1) ? argv[1] : "rgb.jpg"; + + vector colors = readColors(); + + //! [Create the importer of Caffe model] + Ptr importer; + try //Try to import Caffe GoogleNet model + { + importer = dnn::createCaffeImporter(modelTxt, modelBin); + } + catch (const cv::Exception &err) //Importer can throw errors, we will catch them + { + cerr << err.msg << endl; + } + //! [Create the importer of Caffe model] + + if (!importer) + { + cerr << "Can't load network by using the following files: " << endl; + cerr << "prototxt: " << modelTxt << endl; + cerr << "caffemodel: " << modelBin << endl; + cerr << fcnType << "-heavy-pascal.caffemodel can be downloaded here:" << endl; + cerr << "http://dl.caffe.berkeleyvision.org/" << fcnType << "-heavy-pascal.caffemodel" << endl; + exit(-1); + } + + //! [Initialize network] + dnn::Net net; + importer->populateNet(net); + importer.release(); //We don't need importer anymore + //! [Initialize network] + + //! [Prepare blob] + Mat img = imread(imageFile); + if (img.empty()) + { + cerr << "Can't read image from the file: " << imageFile << endl; + exit(-1); + } + + resize(img, img, Size(500, 500)); //FCN accepts 500x500 RGB-images + Mat inputBlob = blobFromImage(img); //Convert Mat to batch of images + //! [Prepare blob] + + //! [Set input blob] + net.setInput(inputBlob, "data"); //set the network input + //! [Set input blob] + + //! [Make forward pass] + double t = (double)cv::getTickCount(); + Mat score = net.forward("score"); //compute output + t = (double)cv::getTickCount() - t; + printf("processing time: %.1fms\n", t*1000./getTickFrequency()); + //! [Make forward pass] + + Mat colorize; + colorizeSegmentation(score, colors, colorize); + Mat show; + addWeighted(img, 0.4, colorize, 0.6, 0.0, show); + imshow("show", show); + waitKey(0); + return 0; +} //main diff --git a/modules/dnn/samples/googlenet_python.py b/modules/dnn/samples/googlenet_python.py new file mode 100644 index 0000000000..53ccdc5518 --- /dev/null +++ b/modules/dnn/samples/googlenet_python.py @@ -0,0 +1,34 @@ +from __future__ import print_function +import numpy as np +import cv2 +from cv2 import dnn +import timeit + +def prepare_image(img): + img = cv2.resize(img, (224, 224)) + #convert interleaved image (RGBRGB) to planar(RRGGBB) + blob = np.moveaxis(img, 2, 0) + blob = np.reshape(blob.astype(np.float32), (-1, 3, 224, 224)) + return blob + +def timeit_forward(net): + print("OpenCL:", cv2.ocl.useOpenCL()) + print("Runtime:", timeit.timeit(lambda: net.forward(), number=10)) + +def get_class_list(): + with open('synset_words.txt', 'rt') as f: + return [ x[x.find(" ") + 1 :] for x in f ] + +blob = prepare_image(cv2.imread('space_shuttle.jpg')) +print("Input:", blob.shape, blob.dtype) + +cv2.ocl.setUseOpenCL(True) #Disable OCL if you want +net = dnn.readNetFromCaffe('bvlc_googlenet.prototxt', 'bvlc_googlenet.caffemodel') +net.setBlob(".data", blob) +net.forward() +#timeit_forward(net) #Uncomment to check performance + +prob = net.getBlob("prob") +print("Output:", prob.shape, prob.dtype) +classes = get_class_list() +print("Best match", classes[prob.argmax()]) \ No newline at end of file diff --git a/modules/dnn/samples/pascal-classes.txt b/modules/dnn/samples/pascal-classes.txt new file mode 100644 index 0000000000..a3a62c1911 --- /dev/null +++ b/modules/dnn/samples/pascal-classes.txt @@ -0,0 +1,21 @@ +background 0 0 0 +aeroplane 128 0 0 +bicycle 0 128 0 +bird 128 128 0 +boat 0 0 128 +bottle 128 0 128 +bus 0 128 128 +car 128 128 128 +cat 64 0 0 +chair 192 0 0 +cow 64 128 0 +diningtable 192 128 0 +dog 64 0 128 +horse 192 0 128 +motorbike 64 128 128 +person 192 128 128 +pottedplant 0 64 0 +sheep 128 64 0 +sofa 0 192 0 +train 128 192 0 +tvmonitor 0 64 128 diff --git a/modules/dnn/samples/rgb.jpg b/modules/dnn/samples/rgb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f78e6e44e1f434031714d8c149475f2347a73256 GIT binary patch literal 47099 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 XS@P~_TXaeYIM14S_xq-bV1NJFSKO9# literal 0 HcmV?d00001 diff --git a/modules/dnn/samples/space_shuttle.jpg b/modules/dnn/samples/space_shuttle.jpg new file mode 100644 index 0000000000000000000000000000000000000000..412a919694c0b0141ba0fa7003fbfc800dd1040d GIT binary patch literal 27598 zcmeFYReT&hvIjb5c09(InVFfHnVFfHW2TsynPO&UW@g5iV~ic+b-uH^=XW0N!+pLh zP0whgQngf4cUS$Z`eXHD7l0%sCMgC00RaIRd}hGM9>7A>!_o`@kd&kXKmz~(FaRH;o{=JMNe<%OlN3fZ)8emY;Q~NVdy~5NXI}A;NkahFf_I{bs;b^ zHMg|mCHmFTLquR{!b_yiD$5}2AZ%)3DdFX0s_Z4FV(evY%xOZz&qu)H!R2A=U~B4P zNZ?^>W9Q7}!AtZHbFRj7-&By?#4v)$-~LS zj7v#G>|Y!{|M3$2YpCw-?sV?VboNf>^o*RGob(J#^h`{&pA@vto^~#V9<+AO#Q)|X zV(M({Wa;2yX>UjHm!qMPy{ii^(dYU98JOv(nE%7~|A^pk%Re&sH>r!I+5Zda-e_3!z+8Uahs#}`4Sp2)o z|5i(wTAEvY4xEYkKjiXGmZqQ6{W~>YB1R(mPnpsGOK5+K|5*b*g8!!fO5nc|_^$;1 zD}nz?;J*_1|DOc@SBo>X`&8ZBKXtT^4S+BJ0t_4+91P;~3jzWH5(*v~>N9355s^jfjT| zM8*66oId&iKxhyF5CJd{A^<251PloBF$loJQxT76bbB8JqGD-)4M!I(t>pnuQBdH&2CD{hRKFMg&`qxVJ?QxR+1DZ z7bdroT$Lmw$xp0JpMyqcoxri4+L18(-eNn~vy&icO-Vu$mmnkwLyk#~`LE&^b?j*| zgb8w6k%ZtxC3A63y-R)eQZbZj{rQQd%b{#q)5QG5e3IYDj~h3 zwYB%EH#z@|pYpg@P;b5ylW7jZhRt9$U?6C<+)mGLjMtbduZ?e9LoU;lDj6oTuV4_x zcghwOQJhG-S9U)bh2|akH>hHW4w}0k@8E%bU@bZNaAJ@ z1#8;&Mnj#=S{!jZN*Qq6>m=&jLua?`T1mrbt{vB_mAULJo1vjz+G$x?U@RIQu7%4Q zy;)3n{K%J{>t;RKQOztj`Of3fmJL%I-FfQRv8vWcFJ|F(F7?w1Ue^dcT0B=mo?w$p z3;L9~0gGh%`$K7_536>;z%24ff4j0=J_&=uLyG3mWmNVrm|qLpJio+$vbo?Y{MdY= zGqkvFr`7Wixp-NR5|jjL35o`ln@C|eb)*&!H10G0RHM|9RAE2pRHE%`P=P4ih+dhP z-TWR*(nS@YWQN+3EA$Y{cVBrmlH@h4dGsg#INeLE7-K@}3cz7)w+0w0_ZH^c;U!dQ z9b60GMiR5R#C^$bh0|+u|MHc-PW%hyh=oTBw}V}*?lr!&8!EitKSO@{B1l{p zdKaf1@Oo!AcJR3`&BY=Xo_AZO`0~QGa3Pn|NT@R{R>BC^&t9xdS4BVGWJ$HJw$ITD zS8NTDdl#>ye*Gd|F;ddK?0a!0V>u3Cik35hws}U~R-{Y_BOvZk9aDx=YJmEu>g@oH zhv!`GC#;&FskbY(tkz<5=8DB4e#5la&8c(V!*Y$o1vg2iQPr$5G>Cc6-To#WL^I(r1jqug3sln|l zpQ_Z&)2GCV3xQi8Ui%kvs|Tugv&8PI0g@dHRq3&8h4tq&@GB3>nd^4QA!Z17rewq584)S zdd|_|>6b-%hPUcibUW*rU5?q3f8YQL)#p(>me$3=FUHUh<}gxa8z z6vSURolManf_xmW* zJJ9i&OYsngkqNH#=rC&zHc&+Aeup}N(JA&@U3QG!ko9oCTHQBaPv9uMM9YfsO3cbQ z+joXI$r{XQ(9CKyG;?B=Jz@}E$SzmLYw%IsQJ6$0rz(v4m1(34vp~o0cv9z*EJ;bD zLbSyvty#GwtW{WaRJOz#V>N2or)hdtZcl|0#d&8dsl@A-1}~{yLm?*ZGaG>g6p^&% z7?pDLw3EuZ>4?W3w*)wC3J6ZZNJ$Dn%!ax`uZd_lOA>-sZOpV}=J{YAXscLK)#>%J zX7t5zJAL2XI6eb5eh?BVgb_WC#>gLLx{sMkGN3 zViE=>W&t4u7WB_21oS5n2n1-Ie-TOM>7gw_POkiu|K1B>94$v_bS^y{{+9leYtlZZ zhr89?{Lt5@Fc<&5rRp`s{iHH8wd6_scl)QGt;@bGe7dpm!v3ace_F}W*Jy4=|&x$w)hJ;mUA`u*`su-!ER8Ei+5v#Q404Y%1}F&qkeif=7)gf43o zCVj$6ntoL7ock3_7^)GrsWpxghH9)N5g&HH79t9NZPBZ{rCTy~<5Ui>dUKVnXjgns zed)+dSx*)}<9PAQgUyOFPiPp|JfeBl#*c6BQ{|T>tp5O%(OkNuPCXvWGt4l|P?jd# zjn{js$y2SCZJvwy<&LDt>R+AmzkUFQCsC;(wVb?DUUH6mbz?B9(J<~!bWm-MtOJd^U~WIq^gW6gRL<1gw5H!buB&{wSIIj`!s#bi{E{?>gVI9^o#Sg@zGMGpN1RQ2a6M7}L^~?G&~3-NlA(7|0jZu%AQFBFoRz z+-mVR>bS9X`Js0T*?W}RZm}%n2N{uaqf?MMeIUQrnIoA4CN?No1ay;YQo5SV=P%^E zRsIN9J@UpXuA=d0JWibI*uBeYHfksG6;@y173?S<%XD{S`q~_$=cG&gu9P{V{mp4b zmO&O6&ndK_3xE!v7|3n0Me~pHkHE*Wo~QLu`T$6YW|-JfH&7t7++QLM6F~+kpD?#q z{Aiy%<52mj_`nCrF5mWTA2En+91LUD-`Ujc0bD3v7v#s39JZ+*^BtWnDj67NbH%%i zuhVA5o!L>xk)i=DRuwF!))$4k z4*-tg?^HkW#~)QSRN|#Fq!MJ90Zi! z;UFk1501OOk=6b@;SdqKoXEw4{q-C)jRXrMws1TD{cy;k zv_Sai2k(6rn#n=BxWweCb7N5B z^`w-GHQlr;tx=w8Y>LYat(`ut*AyB@-P}0V<$?Fc`{S?L?=!cwYW)zMXm8|1AK94B4Jub90GB9$h|*C7{aWj9C}C)R!xn4}6cbk; z5nkdeBm`l|mBlr#&c}j=e`H}BgrZ?zV2C*@Ra940qcwv7yFbHK%hKk;lN=jE@;965 zO~aIyjb3VGWF8h1VXi9Ei=%CdU=X~N-}6TgvGm`MwyYvuwbe=iE7~2mT2zVBfi2*T zjEG-!I8EoZCt4&oKb8O8_m(*w@M>zr$41J_S?_p#t&aC=p@LX*{^G|v-F88)^%J?U z-#X(O7E*9E66`Tw^{M6>$4tO7gN^$67BAs*WZUCK45#Osrtoi+$7huffcm0Wh=y3H zG|JNiMLIem?(<%I`JpmTq?D=(<5nM1lzmrv0OcpU}=Av>D_nq40}g{1JES z?22aUGiEtDci^9yJQLC6c9K&bgLHs(dG)2mM|TRBYaw5hI2Rj0 zuYBS9WazXtEjD_8-{HbIyh26(HwSLth)l%L2>veBI(C?m-_iF&b7I7YGfSCyS&|-L zLYGL%aHVk%97@o1s?<(;?!xtX4O(wYURJyx?IX#V%OhpaoBt!$-jdfaZ$-p11gq~u zxL=nizt7m}0KxWdGgXDsQc-*I!A1&#;IOS2mw$3@X7Aw#plThtPFoaO`w!LW#?|4m zKaso5<>Rk|;o(}-Ov5a0&|Huhz zrr(HgaTgp;!5e=F-%v2oJr9C!CIIc!L&&!WF0OX~meEm5Gx~d-WhFg0!kPbC-mBjU zX(0a073;J2=WVzt5RQh{zTNx5ZcjJEMuI9j*rVq?3P z6cx#W3Bt*%gvR@XP%6f=yzFd*YY5xk=Io{{V&SW6lV5 z(h(fTW;Ust=8kg13ixe^vdCjdfw=6XYroz|--^FU=BFv%y#3p?Mi%Py3=9M*zA9XX zjP7A#dlG?n0OSp-%z(&mx7Y0Fm1Hi3WRMxc5K3&%-~)(mdadE|Z*Sl1(TjPL$i@=a?c?fzy^Oz=z(S1tmn?_ zj_#B-PYqM|>}SZ=!^khM91ynnfPDn{q;U*~ZSymNjRvo@RN$=CG_N6PZ%V6Kfgi(h zXHd)#=Ds5{Z1WXAiA2`UaZ$LeC{6gJE6W~ogp6_%mq2^zAoLFjzqpl*g29*NwDQ-9g7=u?OW zUmOKDyt(d?X4WERsmM_*7Rv2*fTmK}OQAEFJKCsYzV7e3`vwqUkV&}Hdt&I*)_6mn z7mzSty{>A5y!ZJ9%j@_^UJU~BBeg&!-%U0GUHKi#=2S)WWv{oB^NU2}tb1wnCZxHg zIp-JNoTaO0D1ghL0#Ab7G?eph8E$dn1?5%ZNMS4ER`f@qKZ|oetpZ};r_U4w>@R}! zZwLtlhzyEE2!=wyz$mCFfclRm@M$pcg9NeqegMd7x`!5Qyv%oa^?fOkv@H1%OX3TV zGNr6u4%j4gSq#1_mdXIj$qZuF-+}(nF>K*OU*Sp&IT%W9vrCMo7v9rk*BMF8h(s4H zdkW;ejMA?w%xJZ{%JSVL22YDUSuOR0PD|*b@xF`8G37PCF^pGci@cZyh? z?OUH!`G*h@jCErA@LfD723yX-oadm<-Ftb4FO=B(KFji;7C-be*~-Ft&L?${w=94G zi;~xgR{BzjetOSDturSk9nX4cGccH261Nm-Av20m3~7lT_+o7M2LWjp7!bX1o{(W+CWQn`-7vn?BId_V0n$OuNjAgD-W2rhu?81Ro+LH~+%9@k$k z{Nak9MBOOC*Xv-V!HZp@Cvk{u`c3g+tOD^JEIUP9O5jOQSPsYH@H$Go!A)(`5ch7=xH!gk;}sT1>D3*NbXc`&`<( z&hqd?6PPHJ3u#$T;eaaRV%3;5n*W>B6gkQlL0z0av3RVGtkRFzH14`Jl4UY29eH)@ z^nJ9a?&;k|jV^d88^%F=Mwa!w%m>-PpA)B*wasnj@7LQO7zo5!+5-t8`h~ zPN5_wCgJCaKK(LAW=_nBIZ;TaeXka~X1`u#QAMx4eBX27q|9i_l&)XjV@lr;+Yofa zLFvrq~!=Xw$oa3J))(Wn@H66x>u0 z`dvnfq99UBQCJL;2-T(P@1lt!eO?5hppa1DP>>Mdf7k639R-3BA~PZpF$pThgQGAT zItC;V2sz~wGq42K&F!HID;X8^2`D69-$0NQ)*A=)|I1{CQ>*VvN}1>egH@Yh>k^HQpH;zfh#uX@qAXT zajrAFnY;X7Zl#7djNP41rgtiy^1zs_i`BoQ*tt~|y zZQ4|e~>mo%;Em6Zm)y7WzJE(T5+e^$P~6&$iTOQ zE+cDbcZBiUfJ8aV-VJECtNY$-a^Ui5`i)a>ad%dFt_x90v3&>xa1y0QI}t!!u2{^gV38ZE*@81p4u-{GE)C z1Y*z@q56yoJ@eC>NHQU3wsx@nZ$}q*yx#$?+)u|1O!e-hNalUktOH|4XIpqM-w_fH zOvY&+h0cau;XSEjqgsvltg`9%na9K+w_Ht|_j6vKJc!tA$(_grI_$<~EN3^wZ>BFPg?o^cwm({kR+lRLOpVN;(wY}?9^#C-Um2cFZn)E? zdV-2jjLCjkMtXMBH71fG6DLhOZ0?pge@$5v$r@AIz@2DxXXW@F?C3MzKk-=V($YM+ zb~8&kOtw&mANh;|ju5@4R6-B07|K1q=!XxQwV*VF{!kUZjgI3qH$aLRm;w0^Fhc=b zyKB>+7IN>PyKQLfDnVlB}adpbu9o)IXUu zFmo5ejW!&QniO{0BE+4gs@>xXJ`wcDT=-rq(=Qh9IN-Qb(XEcUR}aHYYG%_Z7R!qieOch5 zDPCu4ni7?S#lI?JVvTEVVJ>EOVxKNk!ekMm`}$S6lyi<$+b^#2Xdo~Gc7oe(&N*EP z#jeStOo0d8shFd%O9GQpy}ntB6alNO>KQ@Yrg5SZl!Y>tvsY%Qk-d1n%ylcGp0fh| zS+P{9qhhDtS%r*DAQ~47T!gbDH!?DPX=_CdA{MjmgevYdPyC+>BB{7wEtR9f zE|1eI9S=hG`c1{%VC+09jwFNg(3!}#ZyvN-30orq%o!x#lhqzA{l!l%!&vs{bWJUt zOPK=614sK~V2wONj7?EIHOHq6t-fJ61wJHIII3?(hHL&71*O#8^M)OO(@X`zDhWtJFC6pJH?<*8a_)gRd<>%4a7E1QIO49z&$QI17 z(GBMoTQOE$!!Z}0Qq;W@`T|{vCkeLWwrn?X(4ynICBkj+4wt7T){I=7)R^-mcQPh5 zs;>Q{+ia=LR4Qq9x;UpjsWG%wd&Y4SN);c@4&3e(s+abg*v+FnG{Of|o6EML&c8tE zZ;)2fmrKsC&U9%PxWwL%_y5Ln#ZDtax2&8|!G&rQT4Qd5OcgnfYC$e8M26UcEk!D6 zA|km#E`>R4$+MCWY{doZa--!V6etec{oFInWh0F=-JxmV$Cp3Pu@5dclkX=zQ#gO4 zq*xVlr9RwmD1(Jhfcsh2rn&EeXgeqlKa(jSH}yFlbQv1-M}dvyaHm=-!Z>fsDXEbo zVEndyP+A};c@w*b8JYSLaTtt{+k6 zx32)JcJBlkb7@Hj^dXQLpN$N%s8!x*PCIh8&pE#(D=&%xiBa|yiZIc$Uc!Es7Poz4 z?T;r2q4SP@Ovd6~esJ9m*lZw@6pX*!Uo~6Gf@jW&EqHqK=zv z>nw{w+Aa2mthq`_Kv>rB12FQo#N$3_2hxh8#$|_SIT~BmCL1Q#N^NO=tF2GE4)K|r zIPXWxc4_9i{1#rAH+AU4oJd@>w!f;cQG2P;uT{W(06>>dmVDuA%TK7hGIA0MfA|** zTE%U6ocKp}>nkrSy5Pk7il?^zqN=c3w8p|A2C7v>?ZGmrQ1P4lv#xSyT;QJRo4+^x zR(oEq!V=DSn|-OUt-7}QZp%ljfrIIH6r{w1j{8roX9fbA9?w z6t=LO`@QV^47lBtb#UC^&gyV*T)i*_IW&Wcz0~}6=2Rbav1M9F>I%K92?3F>8)a%! zm0aJfHmV8HW;BFU3M7>yp0ceJ?6W%epkc*@3S2Ii`2wT$u=A+FzkO(4L*Du1XMv>x zaHBb5=_q9Bh<&*h<6?Gt?P0}lSYY4Vffj{?iQcB{rtagN#WABRA;{mkkczc3)l={6 zI_fgEtBr_{o3#S@!Ay-=yG6{RWiWz(Q1YkWoE{u&c+WXzj*q{fV*(0kO~Ws_FKHr3 znl?EZFjQ97Lw~Wf*p$qwXIIOXLeXsn0g{UUWlSpy zYR0P>1b5u4Z;YGOvC9N4^jkwFc~JUeBn}*kVnun3Fx^7|M#m=dWuarGPkPmsFx!QP)1=Q9rS;%CCv95eo zTrv$tD|ztg>OvCS+xGTD?U0KoOUd<+a>3#TCjA}ix>9_6C+Ez7Zyl6lw(|lHjmI4H zjV)spm&}jq23OL`gECL02V zz1b@FsXEi+7OYlQB`sCu#+x-tEvzrAPbmYjJG!Y4Xsd{(ATQhm5O%Th35dS1CXY?f z`4ak1pcm!OYNNj)gZ9H>vKrHssTrydd0f8O5W6w~1DjKc5 zCC(Qf=$3O?*Xwk59}U&KyC5{w_}{G6vi*fF+Qms%)s8WYJ^&iJvG1yD4R4}#(#vWp zQ0bbpc%pj6gpU~OnC}^v*kiW0MsZfTu-3*!_>goXMYn4C`WY|0^6WJYAAm#MAgHM2 zDUiq1D=5|$;dymi8Q($wE2w<^qFgfi#-&5FbF~NB_U)!$x!tO3Z=%2@RyWi?lxLLB zijg+>t~M!9sZW)0fQQid`Vgm%idKq^wR=E!wwrXJPY z88K;s`ajfP5=Kv`VQ0jwz3QljJ-r+)HbZEX1ThAoECyj!;kytSS=qmCp5pkvYa?povzmPXl-BH7uPVMIYGLWJtm4ADwhh1*h&zE{kWZ!5Pqe(}bw6 z9O7^}uA=q}SBE|u#|rkO45=@LPEKyEKpW{ZgwqSIWq z@qiP@7~-!FK#~D6kFa7Lahn`q2|UNC+Rth|-xg8Y(w@)iurkG=Ndgz^*!2rg zx%?*?_HG4PUWHd>!>Gce zPyVVLTX;xKI!8VI7{9PMDG&#JRJgCw*?Nkc@Q#>ef5W{tXD-DY&NhWcPCGqQ`QFmV_aCLXG%st*G`{`HXK@Qdmcs zl5j{K_6ZF>7sVqmkEX^P6EVLl)mxC8v^009HBcUe-X8$T;3gBt^LjI-zO>P@J1{8^D>U*~{8xeJ6NgF2m@F>I zG+u2IGg8)DJNt(h`8T*&P8P()gRkK`@IA|6$T7KjfafGPG}-@@A>8xt3OqP4%%ygvXgS=QWFUIq?3=D=o{Zx-P%0 ziiaU+PnwPmn6+X)0KpSE&#V(^Ehp+%AAo(U)lwiqGb9H_TSC0|JY0lhgPwsR%4|%+ zfL&G^w!#}sz>&Q0DmC_mSMI^x0EO>x- zsco*$EYUs6+Aec-tWR4ORM9!?mLB8@ZorV$a)T^y{MQvr(oga1DcD^ zxY{9S-Zum<7JK_Ey|gBf?Dipa-P#>|@jf4#GhqESG38IF)J}C#Vk=wZ<^c0@^o-DR z&(KNqml7)$F);WplwNN#))$c(KjDfDY#TxC4cN>=yWQ4J^ExPnUmR(JumhFAv}MfY7IVChyGJEAKd+xl6l*fkl>yBOKVwu-&vq}|I6e}&5N~3W&gV(vmF^+LKYLPs%%ctiQfhKRq<9XkpW~}vhJ^Hkn z>L%nqg>U^Zp#=A$GoNQe(T^mMvG10?bS~pZWd`oT3QZ>xQnXQXeUo|1xQbX?I8Eh> zE9)?5gsQEyl_5)ZHjy6CUT;mii)HxSTf(Vd&NCWSzyy( z2Fz(1nA_;Xdt24pSgU=eTD9P>Tazyh*>S6~`yGrm5UCZT%DY5}yN%W8>u=y7I-7I} zaJ)r}1HKQVd0@P8zfqzGJf`PK-Je7f&Cw;VKbo?p*(;1TaBL36Ln1oRL@ zbqY|)Ojv-v8yIh@kR?M-KXd@(~biJ+NuLv&LcONf!4gnU>?KVLo}twfN`?w$Y~6MwV=q0EQd^Mj&I((b~rl2Ca^>k15|| z_0I5GB`~ z!g_u4I)P`nB_n}~eaWUF_8KX$q-!aOoYBb;?gT^yNp=dF>zbjzlt z+wD(9PPhXiykSI{Bh*UU7Om)6f1$7bSS#Rmzja1H-$t)MQ5c&)Ft*xfyG;i0X$}x& z_~8;RSg+B>n{^7*cE?kz64Mg((_JVeE8RsBW{L|;3I>nsiRX55m9z{({5pbkv7JzW zL~G`9iS&fK&+hlS!$R>8IMzYmlF4hzv9O~y7v)uUt7LqN^`p}lI8}-PoKw`=&xGqQ z&~kd(*9~@IA5RWpoQIbz@g8xFNJwjx5W&V7Tq+L$1I5CFZ4eE&%GbHInKKtDl4+Yf zQ$-op^Be)f5K6B9a%CO~W**mN4{c2f08$ z0P>aaP{EXK%n68yi8*?hK9&&m`Dw?X+Y8soO$%!JP&n4+yRE6kXg7Z*N zdEzD!o1_PMR&)@BP`|)Y#fJ$>%z_-_oGAs-C?hWIgF4|h`kPL|%T=fMA7UrTKV9f+ z_qUFJQd{lnAe#oVY=ygJpre;TiVOezd0b;V^U=W}etMh2ta;yf;u_ z6IP#f2$f}#)*vhngLVuKQL}XbZxT(I-6_w^2^rL9Q}zvm=v02cPLgAm;yPoC|FG$gIu1EpUoXHX$;e> z%*X62ZZ{hwK_OSChZ|W()E`NoE2|C`OWAs&bSjMGSTqmj+03j{-l~DHvAO`IwGSYk z@1pf%&kP29J^+~g59((uJvxf7-nob&3Z%YU>_FyYljyWA=)g?|9t6i2rGt*KQXr>N>sPMBG~Nazz2Mfm5# zFU9GSTBjIeZv`3@y0)iIYU|No(yn{|kOrPf|A5k~ahV$mmN(q{YGJw%G{N0)=V^$A zuX>KZF!;z*UiU}(C%k2pxZK>~<;!@?#ALpVDjM0+>0o|l$g%diPP^fXpraPj`h-J6 zIG(w0_Oh8~%vV=l237QI30$~og4&B|jLF8m$LpcP4oT`IV4~BgcdpDA@QniF-~Gh` zwyNVpnQLC=|(nFszQCl_EC0YzMn`ONC8$ zuaIsD22a0Wgp6UIel8v~SL(pA;kOb@yI31hIie(eu2fYkE-bG5D1ZoQsQ4g5&8E6U zx*v$XWG3FNDu&x;ZMNyC(ZX|3^_7L{u@fOr#rvNyI???hkLZlqLc3^@QP~hfM(_%` z;2tSGtffm_ZZX>gYUPqVwhmd_Ne3M;uRD51T#QGis?>*-lWIvEDigqNWOV<%J;>AhD3wn79HvgL(qG? zAmw)nRI-e-VKSn^BCjBcC4F~d*jH*!OTBy~%|Y&xfXNjZe2}7ch9$e31Fjmm!XqLQ znU)D5s5m=KF{AfS#!W-Ax^SDJx|Bg~@FkkUdPF){KS@B5E5Qjx4@;uT4Ai&BS37i)NgWvz7DkIDp?9g+~L8rpmegeSTBAx_=M$m2GZv% z3>tFz5KVkavwgo1VX2t2?S&L3&fzuD-I8q>kJ&aqZ+Z3WT+JMG58E7$a5r?icyp~K z+=B4BPhnPEMBvP5`|$af;Ey z+2;=SNt~LeTTE_AJ+udWoI1}KaEZI zz$Pi>*7Nj`h6CJC==xQ4ix*kmUG3Kiow;AwKH?3EiuH!iL<^p=&Qwl)Kaarr|0Lzi zX>&7zTk;69{t5lg%M9!Bm;xuEc9E3?srhVlkQ)9_Nb6+WX`dot1Zcj(rIe3u@A2agcaL-JkoxZLAyJj%bw-pPhg7s z9k|=G0Q!9#FPySb>NEju4xyyL%yn@R5C?4VsIxMuN8*GBgSA?ZK&5qeeAvnRB%%>Y zqok8duD0Y^6n&qN8nksV|F{$TPjV_bOlgs&TNSCFX^0OhI16{V#36tK`psKe5T3q zn+zvEs_ATuAnE8CGdtW3b0BQriH&*MabIM?LgC~)alA(PsX{4@JN#x-CY-+2&=|Gf zc8@ti(yd&S4Vk9e$=k{p!TUa&Wv#9G?Tv`DN2PuUcR_8NAi$Dmk;XLN-lNGm zjx%bRnbRYeal)B^YrV*;q4_4xsJgPg1*HUDH~GhxLFOa;W5sVhDcb(?m79I$_jf3g zX7OV1%;tz2nKcQe+get7=@DiEl=EFyY9@Nv2aU_t*J!T;UqYEmf1yofOB6-FCv)L= z^jORVZk|Mkg4RO)n9xP|%6>uG0oM95Y{2{+Jrr3!-|-Z*aMf*QTw{qjncW9G-OG$Y z57VFp74BrgXCYvCZGj`PUFC&|!txZ2iL7{AMUyg0NX=p$d6i-yL(n)!MMDd^|=Yq@B zzMK6+pX)hxg03?$2Z%^Q>0YkVjHRD8eHG*>H=u1mjiFa=xVcLh$=Wg@F9ABm^Mg!7 zt#V{r+crW!@diC)qs_5PB8K^q(8JHMC0JDZmy~}3qGOxv9X0C^xey+@ z9QD=zO%0)rIXO!H9ea_}00sI!YPBVw&H!J7?5ud-@{<1(0{rKlz0Y_p001dZkfjeA zAm#%$qbb8}6j$^Ph?nO%h^4unlb=1H_yAOY8vuL*0mrMK2qjcr%Sw$wDu}l%r2dt0 z{fP$RRkG5D?z0^q4ey-Fz0o4b5$U6fcu}Fs8X@v4s_xkfm(2%81S-*HNVxD5Mq_{} zvu0<1m!umlid1K*jifHu5$1I0NE?^OqCWn)S_N$=^~E8RO(b}-4{04zH*mIMlj=MC zNSvX%89^Jo@gxIO+c#;uFO;|G-FS#8EW!-Z=evaCUU@yM$B-%Essu9Mb~uNy$OdXC z`P4PJYYQ`q!Ow3MZ@y>EX0hG+s?{h?k}SP2Tz2e4u7wJiv|=?h=&^qT4DAuWfb&o| z^|v3Hn5;2Wl{(iY;=)Ni&pX4At>=BVM4NO#`}a?N&g1AeMV$`hGzXI zEb9|$MG{mbFuZmQ$iIoNoBIc4{Tu3rR6?Q%mku*Xj+7;Yl#An{neY50N63*?QI6=@ zk0fE)ggAthC1(iP1yhMPMmGdQP{}t6n-*LZ1xLJF%3#wh6a!-$f&1QXkU;o6euY`w@Z|aV0E z=GQf#lu|^Jrui8*!T4aN2wQq^Roy5_MwuWc*taQqm_-iJ@fj2czmZvzND{Ira%1goseW^{`6p$HL2;=WC==O}toilt_Hhp49hzFnYtz zm`~|V^l}ZiB#QSZ3V6sJELvxWf>~{&b-#C@q)ccTnGH^s3`LOXB8oYokivhFsQHrD z2Wg$ZHJ>uR+)4z8Y7Ns)A(vb;sHj{OkuiW~vmxYo_5mpH^EY-G7NPL}+)CuYzgYbz zZvXd1s((WKK>nikpIgcBn&2;RzsK;2-2bzg{s#CV&7*mzV*C8cZh7T4dgOX=ecItZ zux;Kjb98WVUE04)!JP}R|UfL6mUu;aWqrm8BCYMwqe^W zVDk!>TGO-r$MNyGKPOdMonCG$Cf8pca|NT9+)nu6ivdQabWYFb#h*nyD_`Dpwvzr{ za1yMEBfo4m5`GAE_a@Xk(=(1DLg{4w-s=nlf^;{CEY64+j6mRQa4+nnJPEur0d>L+ znL^|2Qjt7b-ep=vNExXLlU)+&T0<1b+N#Hw&4*J?5N6*wa^G}eaN=%Asp%K41-0xw zlQ2V}cTPcABUzX8a5UawM?BOPThA7%K{Ovq^CsbxI20mX-VpX<{`Bh1!FjI1b+Zp| z9QZU!f?RD;&3f>a0M1S+*sq`4 zY-}}tkKt}GG4+O_OipPvabFF^M&YCT(Y$Je?G;fU*s9R0F13^)?{WW%;z-#oohqPZ({<+Nd@ zVcTNc_SEJpc%2*bWOQ4{xC`bu)4^8}Thect=xgFC$g3@6wj> z0<0XW!nmBSD3fsVHg##BS-kaa1tZ;T>fyaw_X+4^2{y6m9*0-NJHyH5+1%o`m5U_E zhP{*<1vNi=B@BN2@)pP7H~?p2|94ydk2C3S-08o9dH>m#|8geP^&!n&?-AVm$CHEv zQEvx?*4d}{evbkc(tTYXhi=d`;}OLLR_N1h=1#XVv`iqyAFC9hTUzFpOz}>oQfZ|~ zrAUn&nItvjk49bj>1ael`~VDzT%rv6$2(*!_ZF>aT9Gx!B%0=VXIg>VE`?>_E6q~} z%uVn*QWAieYuk^10O+r;jQ{X|`h8~XUvKdFhslUBXYOVsJ^(PsoJ0cBA?zi9R=w7R z#dE}KYKVIESa8VEvYMhyMT!fAj14Bah&!TWA+;!T$hZT7`nU2a?F69L|>@fl#0L)MF)}+bZDsir5RZ z1iND`rhh!q}7h3TyS6vIRSk8ERos|Co!<*t9@=N@=saUy*%<24To+f6x%CdX@ zIq4tcH9W`o&rjpbLP1)14a%5iW?5MC3d5ksi#B%!`Ge`IlFHY!Tq0zG(?+~a&(v?s z+59xft4M_*j4#=?pbwM;=eUdNRO(}8NGef9*U?TRebq`=<6j4<;$2-=Nkg6jrNXn zo-9VVwqRwvZyZnD3;LCm9G2zOiUq+CZ~;)`e&YIdc4|YPen_m`CZ>lESQWs0LJSGs zC_b&qUT|)TzHtyGzEqk6rPR1Zsp6m0E>SLd{{Yu|{yaoB4{&_1f?j3z#Nn#Mx+E9>VfvD-d_g>YM=*h3eTC4ORy1IUo+p8sLB3 z{{ZBM^)(v6c7bu=j~B$IOB}=9_Pdrl{QuKv0En9 zl{^r|;c6>6d^a8=5o2c#`F%kloqQma^ppSC}Kq~C9othZM22hXc){)MPsbn-drcd+|lUV%-Uh3 z$eo3vt&^Hzp&-c8)s~0>66w0SFHBYBHYZNq@6@j0kyQ#~)xwq$`WIaw+&(Q@G;bg4 zh>oaCmz%+=sM~CX3@KH((o}-BbEju$mo&2=Y|(LSQ_!?8>NvNtjLfBh>qKA&TI4UJ zv=k;Q`X!05)kd_b$5;SS+OlG<;ruHbmj3{(nbVD(*PjfrHO$K3-M-}~mZJ(*i;PGq zXqFSmzDMv$a?Vvs{+^)=V&DR>a(Cm9l{A`MIrGCqaStjN(zs^$aqbJaA;>AtZpSn(883d}ChYkFfn)ggqnzv?nRgy`Ne)1=P7QHxdut#bmy zdKa`K&QdI7+b!p#+F2M`4*AA1MY*6+4N+H;xS2afDZy2(er4ChUJ-5RZpA!)%;a67uMB!KD7kofTUoim#vb$8pRvw>fkF0An`- z!K}|WpVX$^5s7uIcKpDYDJ3*ex#=9DEGP`oH!Y}&bi>bRm|R^@+slX$pcDqzr{-LO zD&|qGG1h~ytGdfa1@Wnw6+Fri{{Z#kQ-)-gs_}kf3!68@!lprH%2vEeWf%drgT05i zYGH?T{&CH>XFJE$#k6^aDd5E%VwZDiArr-%VV^mjZLC1hH*-5EIF-j2iS&Ax> zn+0mISDnl*iF}oPn3y4;K&<`Bg2daK;MUkSh(cx^VyXuQ(AS1xlud>ddH(=zFQj&5 z!Ta+9SQ=99wS7-8ygty%wSFOrmn#(-Dl6Gy%Ca`%6<>QKN?6{Nw&smd(x7>WD;o|T z_bAwuQ$>w^T(RusGU1N3P;+R_W3+VG(wAv@bI0O2GL^2?gVucrV1>*6=9zu~_Yp1v zyHEWi13;_ThLD{X4Ug_pyE=~u!B|*Z5VADqCH^^rrMn))te^GD0QQEPD)+n@g8vnrD1vLE8D3+a8~?RXq?^grMdLxB1;XW(=!@j zKq$vwacvxmKbcO`A-*}51LoLqFh@rFS4i!`xN^S{B__xVescui1D}<6gd1D2c#MAo}9xnB@}FU%moFkb$-(^mmuh6#+v-VWGW6Kz5(<6CMr~I$KgaE z!mjMAnF@hk1MMc%9dXXsEfUzxpX-;FDNQYMDce$pn!$GQ?g2}b<#QYLhTZ=Fa)@tt ztLyg~(6gNR@NO4Ir!g6c6-89z{{Y`GQmqsXV{K>eQO|BGru?x2t~R&o9_BLB8Lpd% zNm;PDx^e3jD%*F1T`N5ysvB2+Ncn0lah-OK3!-&#Oy= zwr`3$9rr9c5MI@KPcYt(GDEL;>Mctyz@LW@>33^HTXa}2L4~{+If5Ff@Aza!(1^-x zCk1TOGZp7O@3f+g<1}o#7!c=(NM~M-A~gk@F;~CLtN>=cjfYMl0CiB%`S5O7c#4VN z#4qI#1xv?jiW#a^-^{#1N*U4Tyd$i_fxzW-^8qMLUPYX=q7f_z>T>sc{veZ9ndEBG z)GHQ+x|+nyBC=j;>ue$_1q~Eo@tIpefHw}NIf}4LQsTJZc*JBP+Msjy1DE(Rb{NF% zT^DNpAyf;SQ+a|hV#I0oJ7cuYI0X>O{3DP|t<`Fek`-*IHk%Lm-cb`E9bLq>G-$TB zq6wbmTcGDv(^A|T2D+Z(Et06&AyihZ zyTbl#jDxLFR7L~6!2=0}6C+L|H==GR3Jf&A6DnQ>FASB_P(_xdIaNCCh=~Hd4tSRO z1HHb{HOB=Q@T_7Y%%X%H2$^}8g>4mT`7s1!PG7(3W2)>9dqV?NW-i{u94G(=hgS0Q zn7CZLSk2?1#=5ZCvu89t)=c-ERxLML3-$LHsZE2GI(n$$c9sF2bN>K2l-n-vdi}-} zlQLd+`KAslHUf(_@e;~X3pc;{1Twl;B3agf=zHPGaG1j=OQ(p^g+h=zSyj^EFm1{m zQ*%2s*ZBC z&ZA|(f)qO050+g`&L{yqKrJ`m$=~8L+`~-&0M7GD!~CD>8f4yMju@*^2s6F`-M6t7 zSj85PRm&_eBWp!eVLk6mAF8)_%RcH9)QcEecI(Vu@T!h|^^Jr>btA$)7u;rvje=Rb zdeq3PDl-27cxHcuST!tGjiT`?!lNiK&3mVPWk!*2A>z&->LQMcS%p}BE+BAyuej$& z-)L&;mb6g-KMZALvay}xw7)_Nu`T=(gccRa6jAt`tH8_4nS=%#@b3O<4+C#{FL=Pp zY@?`ayoU0>sC8IWrjLj`G5-LKL>F~`olF66P;vOEwo$#Gs2q!&5q3`1TG-==f;Yy) zX(`QKM=&=?O1}^@&40=p1t`Vg5$xG2t)yLSRt&db)qhSPIw@~Xm?JJka$exw8fn@u2cunJvVd$U#*NdQ^8{6~YWcEd z?Rw%0$SY%a!N*#bsnr6MXOrA*s9(54O(7xul2&0-UXGl zM!a7UELd>bx@W6@aaMqrG4ol9E`7*#X@nKd75U6U7U&MvFT?UgPuG2*bULf^Q4aFp ze~KLS?{Vb`qhypWtgG)7#w~KKQqnb5q>WHZyc#!&SCeD~5wY(G!p(Ywr~#0!gUo&)RkWLB>wHIfVMS?lwD)30wY16Wvk?+C@FDyq!H`_Y z(l45>8h{r_aJft42WTrs4k>|XC{=dm5fOA7cc|x;kX_We77CN1^8r)lqNApe>2WZd zj@{J*Z_mK51{gE4;L6iIFo6uYgD5O5%XKzXb?Tge6t z+E$mJbF5NQAghCUtpkABXd>sz*!5|bz1yR$OJpdWUSctTkq>p)` zDJZ@3D=9Cr1FLJEvWo8;?<{R$TqCAt*B>;ps@GizVB{_VAUt2V{mLktl$k`n(}?f* z5Q?T&qtNYwJ99_$5DcGK?JH(%}PI>n-im$hU zuJCc1KyJ*PlI2ZBc?ic#Jeq`16nve1hD1zGzXWS z?7A*>=+4AIw^#(`u6A_pvY0p(@-n3cJ#f| zmHS@MHMwP7Be6FHQ-c_>5V4h(1zC5dT}LzpRx~$u0j|){G5{M=`6K9sM6tVf!$NY;JTZD}xBV++zNmI}iS=7E`2HFEl5is8TD+cS7q+tZPVwi}me#p$UuDi? z(f(Uf)Qx%D~P!0%}SSA~s;$Eul>%0c&G$)3!FH(L)&$ErKWs5C} z84xcexbZ~9Iz5!Mw%ec{*y?CY7l5R618T#Oi%A8hhbCf*D~dPKjK$V~qWdK}xiP9d zz$6mcd9EeN2JZ6FER2Yj4dRcwh)XO2blLMS2qk(ea*{*%0?&xkT!hM;)W=v;a&00Aq=PjxJlu zQd_hy7cwz&!)RlcW(Mr!`K2HQFJfE1If-Z>5}P@S317IGV%X|AKQfe-OTIhGB`E7~ zs&ZbTWg51tv@}Z^F$DstU68$nq-Lzairn%c-l9}TO51_SbomKj3}!ta{Nf6}ux+sA z(l{**U@xVhMN4iD@s>Xb@Xr`s+xq7Ecw>XpyZ->GW}@{Fgg00ANZNwE7(P@qv)#Yu zn3HD6-oGV76s;y!Y~M?ZFPswYUJ!Jp_J!Pc}(TP(l;w5rrqL?(ZRdo$Fv!pUR zGDrbwVZZq-IW4tJ>ZXK6VZ1;KE zUucUcw@|<%k=Tj2P^&>7Eo!P8h$?{?PVS`*&49cms6NXtHtMpy(ppy@p@Y~Qg4-VAe4VUsaMKp5VcxZ1Vi z2@Y%*y>zhKzN0eX73c{_b33^9g~kJxVQ;dKuT|iZ4juIs;P~X>rgYIn@o2m zT%-uM*f3h6`nFLjB?6?SqLp+wj+iKFd?zE;Cl!v7rv>yb0{F;8TJQw?7PCSds%tsD zRdl%hj6`x3R<8dP?rbgU*413bVhYmmB0QoHq=WfN0r= zAMMJzRZY?ca}*fRG#tVp+JNsgAdjhl(}t#OsVQSFUOGg;tAgEFru71ui()0M+d)qd z$!>jI1Lc5dgSsihgBh9HO_fgkyK=QXv_rts3!q<}s+i2O}+- z-r}-|m?9bgH_8Cohq-5xguu(C;P@jz17T3pfpw)kEF@P;DFY}C!9cfI{|*O{?3!T>aFpyf-4COEq2jQ z3wpDSUEU#6a2qzSabx(V7e$->BqGrBeEt`j}yDY50vroD(-T^ulas6w8&q2w}=81>XMvFvQ_FUD};)Hdb5(@M;i3 zqr*NRi2}hZ9w37R0RW%{)$emQ*q!T872Hytq7)7>?kSBFESM7+Uf2HsV+d_eh_F`e ztDI5PgI$fS97`($Z~$9rvh5jRjRP17iVAJ5* zAWL`!gj89vk@jX_1;C&>Y8xRnllq%}CJXPAwAk0pXWKFwDM;a%-WHwz00<)2gH`=R zK&vd`hOi;kAYyP<{{UGOpc*nGNN+8E;r9@EKHvaVY^(d!zL&BqKM@<^#spwVRgnCU zWiaZXb>oFJTFMrWAlq*SyG-B38{Kb(D z6U+jU%-o%A=td=gNHhw;u*FavGW8iOQk36lmsoC3 zU4i{_-`0gs#1#aDDscqne3dLi5y$fN%4uwn10sP^oEo zH^cgrp@8xJsmY2tc{lo)Os+GU{{Z7NC610FuoR(@?n_e>NY-GgFhzFl3ft8OJisuJ zEN`yj&cWj5G)uSxmFoM0a0OpBfASGf&8`q2xJgs7S-60$(cF&-(5r}NkkUk@_N~6v z_>>TO5YfHAxsNS_k<)W%fr|vh+l>UIZms06#4N};s#L-eIL?zuTN@SkAGw~D6(x*k zj^G+;8ZEXYC@ph-pc`Q1=zbwLM9`v%xHNL>7!IzIv-2M)r4ApNwqdtJ?pLJ>8_K`? z9gj+A)x}pd2}kii&XX{^0~`D`0g< zF~I`iOu0hfG`Tw5$(Jm$yvKW8AlCkSKsHU)F!M3tL%94-7UTTHWQZkYzM~I8Qe&gu zqFqQx*5fQhR?x#UG|7rTPz~U;Ql4N&8qQUSLMd5oXYNv{QyG783cR)_+Y1mKHkJrD zGGLCl)wl5k@yyf0b2o`z((NHIpl9Z4R+w!+xs*#SD{&E+L{IpYxpYf+a}>xZITLyC zz;l*?lataBM~RS@oSNwq(ZTK|$-G$m6P-W{hy8Jkt8C||++v{{WGTxqT=2 zi7dmLej_inWrZtgj9XHIfX+fRAf8^F#<+06i#X`{nOkDnWpiBEiV|EXA0!Mf{?hKG zY+lAH^=<$@bpnw(WTeHu_QCHeQ3~M>wsO*k2GZ)T;FNW6vrsfHFx$CFY_E8+ z31Hy*nX5-u`j#%MqUHz+j*E^KTF^`-FCkx0zu>J}jkyKVpK!n-t3(7S!qTD9&O>cY za&MVVw(&)O1gEhpf%6qMCTJYMqnyceA)xYC&Y(cn<-7B7DD0$3%8PXm6~{QKj1A8i z_vnk3w>Jpf=PG}2SUJTN{4#*LFo|#?9fH4@U6{59+REu`cbZqt#_@%8;|gi8{Kj5ti~E40Jx{2h~981~#!~9Og2bn-`V$8RDme2@eU<3M$z`NC?Xd7>XL#@XtH^pDn zXi)dd{oW|Zc*OM)_8x2kA$eM>;v*ty&@eL!@lDi^*ptaT--{I9G^RxvmOx-SH5PWuOCF6uy{=P}m{Wn;#JI$WhkUW_(oV z+l0J#KpwlyZ~~C@pr=cXNm>G&P@#mNa|Jt=EN<@8HRBBnm^y-iOXwF~NB~;3xbRe6 zo9(D|P-bEhthOEGUOW&VWg&vPBknkFdlfZhm|t06M&HV~GTn5{!gQfiz^~c>dVxgS z&|10T1PsMQ6TRWMH$#R2Pk#xO6?tB?vdisVY52?nw1TRy<_zfz$)Bo~%I>HFeDCHx z&BazA`L#Q3`ygzj*r8st1z5YP@8Vb|ayA;>^or5$OlRFpl~K`EdPqWEvK#MrD=`LG z9|XE-DphdNm}&^szACMGi+oA@_C6y@LWIJ-(3Q$!trU4U?@*Q#7RC4vaU+DJWv$t0 zeq&&~dy84JpAl8`K=vgNXO*I{zzk&>4+#dC-N%v)pk9l8!44kKH_i+fR8sCP&3Nk$ zad2uq!F)s-Ruii5seYs4s~%nQ52;lkT8jDrvGWC76wB6t0PM%s2v{$Kf7oxmN4a79 zh_n<{cTNZ3j~nwszG#BW0ix`^y+aMdc7W|qxRo$s>Uj)Cy;*VM*=b;5G#%G+&;W9G z_+suzV0tCuJ>af6aJ+PniXA8)n8q1K3VtFv3xF5(3J_K@#rn($L9oibkQP>^g;xF; zc;N^+>u=zfAcHHh@kA)xyEObYGxQvVM)H{T5%5(ObzQzAXmC)|9ALz;Kv^L0W8jzf zb%@d(*72adc8eV|n5~6TQzKg#s z7BK1)u5$R5gT*xE+jjLWnRdZTso)3k1KAdA!^M-7CAbdk2j&4LQL66i`ho717#EA! zg-|lVr0YqS!~y`7<(_yvL)R5nr;|t2MuT`Ws0*Jr9NGyJ0nHk|D=ZBRbIo+PG?Am^ zyFy}>C7ydiD4kxh@L;P7v_bKyQioLCFTBjk!_bKdQMBdxxB`iK+BF@j7|cE{1xf_P zWie2Unq0sIDUkm6GO8R~FS$ultM}<->lILo{qV~!7Mzc++LuDPp_qI>sYM5pm2ZT& zMew>5zQKr0K+v^2@9JM8*5n@cVVBj2gqCoR>M?+{Uh**qqEWNXxzqy+ZlC1f)Ebo8 zUihO%Xlyi5_8H!>+6@NUCGy?hX;C$#uWeXD@!DU3(5KKx&x=j=%QNtNP+9j2`-p}5W#!fozm{p&)u+3u|Jmx90xJLj literal 0 HcmV?d00001 diff --git a/modules/dnn/samples/squeezenet_halide.cpp b/modules/dnn/samples/squeezenet_halide.cpp new file mode 100644 index 0000000000..39f88caae9 --- /dev/null +++ b/modules/dnn/samples/squeezenet_halide.cpp @@ -0,0 +1,120 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +// Sample of using Halide backend in OpenCV deep learning module. +// Based on dnn/samples/caffe_googlenet.cpp. + +#include +#include +#include +using namespace cv; +using namespace cv::dnn; + +#include +#include +#include + +/* Find best class for the blob (i. e. class with maximal probability) */ +void getMaxClass(const Mat &probBlob, int *classId, double *classProb) +{ + Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix + Point classNumber; + + minMaxLoc(probMat, NULL, classProb, NULL, &classNumber); + *classId = classNumber.x; +} + +std::vector readClassNames(const char *filename = "synset_words.txt") +{ + std::vector classNames; + + std::ifstream fp(filename); + if (!fp.is_open()) + { + std::cerr << "File with classes labels not found: " << filename << std::endl; + exit(-1); + } + + std::string name; + while (!fp.eof()) + { + std::getline(fp, name); + if (name.length()) + classNames.push_back( name.substr(name.find(' ')+1) ); + } + + fp.close(); + return classNames; +} + +int main(int argc, char **argv) +{ + initModule(); // Required if OpenCV is built as static libs. + + std::string modelTxt = "train_val.prototxt"; + std::string modelBin = "squeezenet_v1.1.caffemodel"; + std::string imageFile = (argc > 1) ? argv[1] : "space_shuttle.jpg"; + + //! [Read and initialize network] + Net net = dnn::readNetFromCaffe(modelTxt, modelBin); + //! [Read and initialize network] + + //! [Check that network was read successfully] + if (net.empty()) + { + std::cerr << "Can't load network by using the following files: " << std::endl; + std::cerr << "prototxt: " << modelTxt << std::endl; + std::cerr << "caffemodel: " << modelBin << std::endl; + std::cerr << "SqueezeNet v1.1 can be downloaded from:" << std::endl; + std::cerr << "https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1" << std::endl; + exit(-1); + } + //! [Check that network was read successfully] + + //! [Prepare blob] + Mat img = imread(imageFile); + if (img.empty()) + { + std::cerr << "Can't read image from the file: " << imageFile << std::endl; + exit(-1); + } + if (img.channels() != 3) + { + std::cerr << "Image " << imageFile << " isn't 3-channel" << std::endl; + exit(-1); + } + + resize(img, img, Size(227, 227)); // SqueezeNet v1.1 predict class by 3x227x227 input image. + Mat inputBlob = blobFromImage(img, 1.0, Size(), Scalar(), false); // Convert Mat to 4-dimensional batch. + //! [Prepare blob] + + //! [Set input blob] + net.setInput(inputBlob); // Set the network input. + //! [Set input blob] + + //! [Enable Halide backend] + net.setPreferableBackend(DNN_BACKEND_HALIDE); // Tell engine to use Halide where it possible. + //! [Enable Halide backend] + + //! [Make forward pass] + Mat prob = net.forward("prob"); // Compute output. + //! [Make forward pass] + + //! [Determine the best class] + int classId; + double classProb; + getMaxClass(prob, &classId, &classProb); // Find the best class. + //! [Determine the best class] + + //! [Print results] + std::vector classNames = readClassNames(); + std::cout << "Best class: #" << classId << " '" << classNames.at(classId) << "'" << std::endl; + std::cout << "Probability: " << classProb * 100 << "%" << std::endl; + //! [Print results] + + return 0; +} //main diff --git a/modules/dnn/samples/ssd_object_detection.cpp b/modules/dnn/samples/ssd_object_detection.cpp new file mode 100644 index 0000000000..016357c4b3 --- /dev/null +++ b/modules/dnn/samples/ssd_object_detection.cpp @@ -0,0 +1,154 @@ +#include +#include +#include +#include +using namespace cv; +using namespace cv::dnn; + +#include +#include +#include +using namespace std; + +const size_t width = 300; +const size_t height = 300; + +Mat getMean(const size_t& imageHeight, const size_t& imageWidth) +{ + Mat mean; + + const int meanValues[3] = {104, 117, 123}; + vector meanChannels; + for(size_t i = 0; i < 3; i++) + { + Mat channel(imageHeight, imageWidth, CV_32F, Scalar(meanValues[i])); + meanChannels.push_back(channel); + } + cv::merge(meanChannels, mean); + return mean; +} + +Mat preprocess(const Mat& frame) +{ + Mat preprocessed; + frame.convertTo(preprocessed, CV_32F); + resize(preprocessed, preprocessed, Size(width, height)); //SSD accepts 300x300 RGB-images + + Mat mean = getMean(width, height); + cv::subtract(preprocessed, mean, preprocessed); + + return preprocessed; +} + +const char* about = "This sample uses Single-Shot Detector " + "(https://arxiv.org/abs/1512.02325)" + "to detect objects on image\n"; // TODO: link + +const char* params + = "{ help | false | print usage }" + "{ proto | | model configuration }" + "{ model | | model weights }" + "{ image | | image for detection }" + "{ min_confidence | 0.5 | min confidence }"; + +int main(int argc, char** argv) +{ + cv::CommandLineParser parser(argc, argv, params); + + if (parser.get("help")) + { + std::cout << about << std::endl; + parser.printMessage(); + return 0; + } + + cv::dnn::initModule(); //Required if OpenCV is built as static libs + + String modelConfiguration = parser.get("proto"); + String modelBinary = parser.get("model"); + + //! [Create the importer of Caffe model] + Ptr importer; + + // Import Caffe SSD model + try + { + importer = dnn::createCaffeImporter(modelConfiguration, modelBinary); + } + catch (const cv::Exception &err) //Importer can throw errors, we will catch them + { + cerr << err.msg << endl; + } + //! [Create the importer of Caffe model] + + if (!importer) + { + cerr << "Can't load network by using the following files: " << endl; + cerr << "prototxt: " << modelConfiguration << endl; + cerr << "caffemodel: " << modelBinary << endl; + cerr << "Models can be downloaded here:" << endl; + cerr << "https://github.com/weiliu89/caffe/tree/ssd#models" << endl; + exit(-1); + } + + //! [Initialize network] + dnn::Net net; + importer->populateNet(net); + importer.release(); //We don't need importer anymore + //! [Initialize network] + + cv::Mat frame = cv::imread(parser.get("image"), -1); + + if (frame.channels() == 4) + cvtColor(frame, frame, COLOR_BGRA2BGR); + //! [Prepare blob] + Mat preprocessedFrame = preprocess(frame); + + Mat inputBlob = blobFromImage(preprocessedFrame); //Convert Mat to batch of images + //! [Prepare blob] + + //! [Set input blob] + net.setInput(inputBlob, "data"); //set the network input + //! [Set input blob] + + //! [Make forward pass] + Mat detection = net.forward("detection_out"); //compute output + //! [Make forward pass] + + Mat detectionMat(detection.size[2], detection.size[3], CV_32F, detection.ptr()); + + float confidenceThreshold = parser.get("min_confidence"); + for(int i = 0; i < detectionMat.rows; i++) + { + float confidence = detectionMat.at(i, 2); + + if(confidence > confidenceThreshold) + { + size_t objectClass = detectionMat.at(i, 1); + + float xLeftBottom = detectionMat.at(i, 3) * frame.cols; + float yLeftBottom = detectionMat.at(i, 4) * frame.rows; + float xRightTop = detectionMat.at(i, 5) * frame.cols; + float yRightTop = detectionMat.at(i, 6) * frame.rows; + + std::cout << "Class: " << objectClass << std::endl; + std::cout << "Confidence: " << confidence << std::endl; + + std::cout << " " << xLeftBottom + << " " << yLeftBottom + << " " << xRightTop + << " " << yRightTop << std::endl; + + Rect object(xLeftBottom, yLeftBottom, + xRightTop - xLeftBottom, + yRightTop - yLeftBottom); + + rectangle(frame, object, Scalar(0, 255, 0)); + } + } + + imshow("detections", frame); + waitKey(); + + return 0; +} // main diff --git a/modules/dnn/samples/synset_words.txt b/modules/dnn/samples/synset_words.txt new file mode 100644 index 0000000000..a9e8c7f50d --- /dev/null +++ b/modules/dnn/samples/synset_words.txt @@ -0,0 +1,1000 @@ +n01440764 tench, Tinca tinca +n01443537 goldfish, Carassius auratus +n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias +n01491361 tiger shark, Galeocerdo cuvieri +n01494475 hammerhead, hammerhead shark +n01496331 electric ray, crampfish, numbfish, torpedo +n01498041 stingray +n01514668 cock +n01514859 hen +n01518878 ostrich, Struthio camelus +n01530575 brambling, Fringilla montifringilla +n01531178 goldfinch, Carduelis carduelis +n01532829 house finch, linnet, Carpodacus mexicanus +n01534433 junco, snowbird +n01537544 indigo bunting, indigo finch, indigo bird, Passerina cyanea +n01558993 robin, American robin, Turdus migratorius +n01560419 bulbul +n01580077 jay +n01582220 magpie +n01592084 chickadee +n01601694 water ouzel, dipper +n01608432 kite +n01614925 bald eagle, American eagle, Haliaeetus leucocephalus +n01616318 vulture +n01622779 great grey owl, great gray owl, Strix nebulosa +n01629819 European fire salamander, Salamandra salamandra +n01630670 common newt, Triturus vulgaris +n01631663 eft +n01632458 spotted salamander, Ambystoma maculatum +n01632777 axolotl, mud puppy, Ambystoma mexicanum +n01641577 bullfrog, Rana catesbeiana +n01644373 tree frog, tree-frog +n01644900 tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui +n01664065 loggerhead, loggerhead turtle, Caretta caretta +n01665541 leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea +n01667114 mud turtle +n01667778 terrapin +n01669191 box turtle, box tortoise +n01675722 banded gecko +n01677366 common iguana, iguana, Iguana iguana +n01682714 American chameleon, anole, Anolis carolinensis +n01685808 whiptail, whiptail lizard +n01687978 agama +n01688243 frilled lizard, Chlamydosaurus kingi +n01689811 alligator lizard +n01692333 Gila monster, Heloderma suspectum +n01693334 green lizard, Lacerta viridis +n01694178 African chameleon, Chamaeleo chamaeleon +n01695060 Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis +n01697457 African crocodile, Nile crocodile, Crocodylus niloticus +n01698640 American alligator, Alligator mississipiensis +n01704323 triceratops +n01728572 thunder snake, worm snake, Carphophis amoenus +n01728920 ringneck snake, ring-necked snake, ring snake +n01729322 hognose snake, puff adder, sand viper +n01729977 green snake, grass snake +n01734418 king snake, kingsnake +n01735189 garter snake, grass snake +n01737021 water snake +n01739381 vine snake +n01740131 night snake, Hypsiglena torquata +n01742172 boa constrictor, Constrictor constrictor +n01744401 rock python, rock snake, Python sebae +n01748264 Indian cobra, Naja naja +n01749939 green mamba +n01751748 sea snake +n01753488 horned viper, cerastes, sand viper, horned asp, Cerastes cornutus +n01755581 diamondback, diamondback rattlesnake, Crotalus adamanteus +n01756291 sidewinder, horned rattlesnake, Crotalus cerastes +n01768244 trilobite +n01770081 harvestman, daddy longlegs, Phalangium opilio +n01770393 scorpion +n01773157 black and gold garden spider, Argiope aurantia +n01773549 barn spider, Araneus cavaticus +n01773797 garden spider, Aranea diademata +n01774384 black widow, Latrodectus mactans +n01774750 tarantula +n01775062 wolf spider, hunting spider +n01776313 tick +n01784675 centipede +n01795545 black grouse +n01796340 ptarmigan +n01797886 ruffed grouse, partridge, Bonasa umbellus +n01798484 prairie chicken, prairie grouse, prairie fowl +n01806143 peacock +n01806567 quail +n01807496 partridge +n01817953 African grey, African gray, Psittacus erithacus +n01818515 macaw +n01819313 sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita +n01820546 lorikeet +n01824575 coucal +n01828970 bee eater +n01829413 hornbill +n01833805 hummingbird +n01843065 jacamar +n01843383 toucan +n01847000 drake +n01855032 red-breasted merganser, Mergus serrator +n01855672 goose +n01860187 black swan, Cygnus atratus +n01871265 tusker +n01872401 echidna, spiny anteater, anteater +n01873310 platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus +n01877812 wallaby, brush kangaroo +n01882714 koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus +n01883070 wombat +n01910747 jellyfish +n01914609 sea anemone, anemone +n01917289 brain coral +n01924916 flatworm, platyhelminth +n01930112 nematode, nematode worm, roundworm +n01943899 conch +n01944390 snail +n01945685 slug +n01950731 sea slug, nudibranch +n01955084 chiton, coat-of-mail shell, sea cradle, polyplacophore +n01968897 chambered nautilus, pearly nautilus, nautilus +n01978287 Dungeness crab, Cancer magister +n01978455 rock crab, Cancer irroratus +n01980166 fiddler crab +n01981276 king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica +n01983481 American lobster, Northern lobster, Maine lobster, Homarus americanus +n01984695 spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish +n01985128 crayfish, crawfish, crawdad, crawdaddy +n01986214 hermit crab +n01990800 isopod +n02002556 white stork, Ciconia ciconia +n02002724 black stork, Ciconia nigra +n02006656 spoonbill +n02007558 flamingo +n02009229 little blue heron, Egretta caerulea +n02009912 American egret, great white heron, Egretta albus +n02011460 bittern +n02012849 crane +n02013706 limpkin, Aramus pictus +n02017213 European gallinule, Porphyrio porphyrio +n02018207 American coot, marsh hen, mud hen, water hen, Fulica americana +n02018795 bustard +n02025239 ruddy turnstone, Arenaria interpres +n02027492 red-backed sandpiper, dunlin, Erolia alpina +n02028035 redshank, Tringa totanus +n02033041 dowitcher +n02037110 oystercatcher, oyster catcher +n02051845 pelican +n02056570 king penguin, Aptenodytes patagonica +n02058221 albatross, mollymawk +n02066245 grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus +n02071294 killer whale, killer, orca, grampus, sea wolf, Orcinus orca +n02074367 dugong, Dugong dugon +n02077923 sea lion +n02085620 Chihuahua +n02085782 Japanese spaniel +n02085936 Maltese dog, Maltese terrier, Maltese +n02086079 Pekinese, Pekingese, Peke +n02086240 Shih-Tzu +n02086646 Blenheim spaniel +n02086910 papillon +n02087046 toy terrier +n02087394 Rhodesian ridgeback +n02088094 Afghan hound, Afghan +n02088238 basset, basset hound +n02088364 beagle +n02088466 bloodhound, sleuthhound +n02088632 bluetick +n02089078 black-and-tan coonhound +n02089867 Walker hound, Walker foxhound +n02089973 English foxhound +n02090379 redbone +n02090622 borzoi, Russian wolfhound +n02090721 Irish wolfhound +n02091032 Italian greyhound +n02091134 whippet +n02091244 Ibizan hound, Ibizan Podenco +n02091467 Norwegian elkhound, elkhound +n02091635 otterhound, otter hound +n02091831 Saluki, gazelle hound +n02092002 Scottish deerhound, deerhound +n02092339 Weimaraner +n02093256 Staffordshire bullterrier, Staffordshire bull terrier +n02093428 American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier +n02093647 Bedlington terrier +n02093754 Border terrier +n02093859 Kerry blue terrier +n02093991 Irish terrier +n02094114 Norfolk terrier +n02094258 Norwich terrier +n02094433 Yorkshire terrier +n02095314 wire-haired fox terrier +n02095570 Lakeland terrier +n02095889 Sealyham terrier, Sealyham +n02096051 Airedale, Airedale terrier +n02096177 cairn, cairn terrier +n02096294 Australian terrier +n02096437 Dandie Dinmont, Dandie Dinmont terrier +n02096585 Boston bull, Boston terrier +n02097047 miniature schnauzer +n02097130 giant schnauzer +n02097209 standard schnauzer +n02097298 Scotch terrier, Scottish terrier, Scottie +n02097474 Tibetan terrier, chrysanthemum dog +n02097658 silky terrier, Sydney silky +n02098105 soft-coated wheaten terrier +n02098286 West Highland white terrier +n02098413 Lhasa, Lhasa apso +n02099267 flat-coated retriever +n02099429 curly-coated retriever +n02099601 golden retriever +n02099712 Labrador retriever +n02099849 Chesapeake Bay retriever +n02100236 German short-haired pointer +n02100583 vizsla, Hungarian pointer +n02100735 English setter +n02100877 Irish setter, red setter +n02101006 Gordon setter +n02101388 Brittany spaniel +n02101556 clumber, clumber spaniel +n02102040 English springer, English springer spaniel +n02102177 Welsh springer spaniel +n02102318 cocker spaniel, English cocker spaniel, cocker +n02102480 Sussex spaniel +n02102973 Irish water spaniel +n02104029 kuvasz +n02104365 schipperke +n02105056 groenendael +n02105162 malinois +n02105251 briard +n02105412 kelpie +n02105505 komondor +n02105641 Old English sheepdog, bobtail +n02105855 Shetland sheepdog, Shetland sheep dog, Shetland +n02106030 collie +n02106166 Border collie +n02106382 Bouvier des Flandres, Bouviers des Flandres +n02106550 Rottweiler +n02106662 German shepherd, German shepherd dog, German police dog, alsatian +n02107142 Doberman, Doberman pinscher +n02107312 miniature pinscher +n02107574 Greater Swiss Mountain dog +n02107683 Bernese mountain dog +n02107908 Appenzeller +n02108000 EntleBucher +n02108089 boxer +n02108422 bull mastiff +n02108551 Tibetan mastiff +n02108915 French bulldog +n02109047 Great Dane +n02109525 Saint Bernard, St Bernard +n02109961 Eskimo dog, husky +n02110063 malamute, malemute, Alaskan malamute +n02110185 Siberian husky +n02110341 dalmatian, coach dog, carriage dog +n02110627 affenpinscher, monkey pinscher, monkey dog +n02110806 basenji +n02110958 pug, pug-dog +n02111129 Leonberg +n02111277 Newfoundland, Newfoundland dog +n02111500 Great Pyrenees +n02111889 Samoyed, Samoyede +n02112018 Pomeranian +n02112137 chow, chow chow +n02112350 keeshond +n02112706 Brabancon griffon +n02113023 Pembroke, Pembroke Welsh corgi +n02113186 Cardigan, Cardigan Welsh corgi +n02113624 toy poodle +n02113712 miniature poodle +n02113799 standard poodle +n02113978 Mexican hairless +n02114367 timber wolf, grey wolf, gray wolf, Canis lupus +n02114548 white wolf, Arctic wolf, Canis lupus tundrarum +n02114712 red wolf, maned wolf, Canis rufus, Canis niger +n02114855 coyote, prairie wolf, brush wolf, Canis latrans +n02115641 dingo, warrigal, warragal, Canis dingo +n02115913 dhole, Cuon alpinus +n02116738 African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus +n02117135 hyena, hyaena +n02119022 red fox, Vulpes vulpes +n02119789 kit fox, Vulpes macrotis +n02120079 Arctic fox, white fox, Alopex lagopus +n02120505 grey fox, gray fox, Urocyon cinereoargenteus +n02123045 tabby, tabby cat +n02123159 tiger cat +n02123394 Persian cat +n02123597 Siamese cat, Siamese +n02124075 Egyptian cat +n02125311 cougar, puma, catamount, mountain lion, painter, panther, Felis concolor +n02127052 lynx, catamount +n02128385 leopard, Panthera pardus +n02128757 snow leopard, ounce, Panthera uncia +n02128925 jaguar, panther, Panthera onca, Felis onca +n02129165 lion, king of beasts, Panthera leo +n02129604 tiger, Panthera tigris +n02130308 cheetah, chetah, Acinonyx jubatus +n02132136 brown bear, bruin, Ursus arctos +n02133161 American black bear, black bear, Ursus americanus, Euarctos americanus +n02134084 ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus +n02134418 sloth bear, Melursus ursinus, Ursus ursinus +n02137549 mongoose +n02138441 meerkat, mierkat +n02165105 tiger beetle +n02165456 ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle +n02167151 ground beetle, carabid beetle +n02168699 long-horned beetle, longicorn, longicorn beetle +n02169497 leaf beetle, chrysomelid +n02172182 dung beetle +n02174001 rhinoceros beetle +n02177972 weevil +n02190166 fly +n02206856 bee +n02219486 ant, emmet, pismire +n02226429 grasshopper, hopper +n02229544 cricket +n02231487 walking stick, walkingstick, stick insect +n02233338 cockroach, roach +n02236044 mantis, mantid +n02256656 cicada, cicala +n02259212 leafhopper +n02264363 lacewing, lacewing fly +n02268443 dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk +n02268853 damselfly +n02276258 admiral +n02277742 ringlet, ringlet butterfly +n02279972 monarch, monarch butterfly, milkweed butterfly, Danaus plexippus +n02280649 cabbage butterfly +n02281406 sulphur butterfly, sulfur butterfly +n02281787 lycaenid, lycaenid butterfly +n02317335 starfish, sea star +n02319095 sea urchin +n02321529 sea cucumber, holothurian +n02325366 wood rabbit, cottontail, cottontail rabbit +n02326432 hare +n02328150 Angora, Angora rabbit +n02342885 hamster +n02346627 porcupine, hedgehog +n02356798 fox squirrel, eastern fox squirrel, Sciurus niger +n02361337 marmot +n02363005 beaver +n02364673 guinea pig, Cavia cobaya +n02389026 sorrel +n02391049 zebra +n02395406 hog, pig, grunter, squealer, Sus scrofa +n02396427 wild boar, boar, Sus scrofa +n02397096 warthog +n02398521 hippopotamus, hippo, river horse, Hippopotamus amphibius +n02403003 ox +n02408429 water buffalo, water ox, Asiatic buffalo, Bubalus bubalis +n02410509 bison +n02412080 ram, tup +n02415577 bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis +n02417914 ibex, Capra ibex +n02422106 hartebeest +n02422699 impala, Aepyceros melampus +n02423022 gazelle +n02437312 Arabian camel, dromedary, Camelus dromedarius +n02437616 llama +n02441942 weasel +n02442845 mink +n02443114 polecat, fitch, foulmart, foumart, Mustela putorius +n02443484 black-footed ferret, ferret, Mustela nigripes +n02444819 otter +n02445715 skunk, polecat, wood pussy +n02447366 badger +n02454379 armadillo +n02457408 three-toed sloth, ai, Bradypus tridactylus +n02480495 orangutan, orang, orangutang, Pongo pygmaeus +n02480855 gorilla, Gorilla gorilla +n02481823 chimpanzee, chimp, Pan troglodytes +n02483362 gibbon, Hylobates lar +n02483708 siamang, Hylobates syndactylus, Symphalangus syndactylus +n02484975 guenon, guenon monkey +n02486261 patas, hussar monkey, Erythrocebus patas +n02486410 baboon +n02487347 macaque +n02488291 langur +n02488702 colobus, colobus monkey +n02489166 proboscis monkey, Nasalis larvatus +n02490219 marmoset +n02492035 capuchin, ringtail, Cebus capucinus +n02492660 howler monkey, howler +n02493509 titi, titi monkey +n02493793 spider monkey, Ateles geoffroyi +n02494079 squirrel monkey, Saimiri sciureus +n02497673 Madagascar cat, ring-tailed lemur, Lemur catta +n02500267 indri, indris, Indri indri, Indri brevicaudatus +n02504013 Indian elephant, Elephas maximus +n02504458 African elephant, Loxodonta africana +n02509815 lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens +n02510455 giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca +n02514041 barracouta, snoek +n02526121 eel +n02536864 coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch +n02606052 rock beauty, Holocanthus tricolor +n02607072 anemone fish +n02640242 sturgeon +n02641379 gar, garfish, garpike, billfish, Lepisosteus osseus +n02643566 lionfish +n02655020 puffer, pufferfish, blowfish, globefish +n02666196 abacus +n02667093 abaya +n02669723 academic gown, academic robe, judge's robe +n02672831 accordion, piano accordion, squeeze box +n02676566 acoustic guitar +n02687172 aircraft carrier, carrier, flattop, attack aircraft carrier +n02690373 airliner +n02692877 airship, dirigible +n02699494 altar +n02701002 ambulance +n02704792 amphibian, amphibious vehicle +n02708093 analog clock +n02727426 apiary, bee house +n02730930 apron +n02747177 ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin +n02749479 assault rifle, assault gun +n02769748 backpack, back pack, knapsack, packsack, rucksack, haversack +n02776631 bakery, bakeshop, bakehouse +n02777292 balance beam, beam +n02782093 balloon +n02783161 ballpoint, ballpoint pen, ballpen, Biro +n02786058 Band Aid +n02787622 banjo +n02788148 bannister, banister, balustrade, balusters, handrail +n02790996 barbell +n02791124 barber chair +n02791270 barbershop +n02793495 barn +n02794156 barometer +n02795169 barrel, cask +n02797295 barrow, garden cart, lawn cart, wheelbarrow +n02799071 baseball +n02802426 basketball +n02804414 bassinet +n02804610 bassoon +n02807133 bathing cap, swimming cap +n02808304 bath towel +n02808440 bathtub, bathing tub, bath, tub +n02814533 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon +n02814860 beacon, lighthouse, beacon light, pharos +n02815834 beaker +n02817516 bearskin, busby, shako +n02823428 beer bottle +n02823750 beer glass +n02825657 bell cote, bell cot +n02834397 bib +n02835271 bicycle-built-for-two, tandem bicycle, tandem +n02837789 bikini, two-piece +n02840245 binder, ring-binder +n02841315 binoculars, field glasses, opera glasses +n02843684 birdhouse +n02859443 boathouse +n02860847 bobsled, bobsleigh, bob +n02865351 bolo tie, bolo, bola tie, bola +n02869837 bonnet, poke bonnet +n02870880 bookcase +n02871525 bookshop, bookstore, bookstall +n02877765 bottlecap +n02879718 bow +n02883205 bow tie, bow-tie, bowtie +n02892201 brass, memorial tablet, plaque +n02892767 brassiere, bra, bandeau +n02894605 breakwater, groin, groyne, mole, bulwark, seawall, jetty +n02895154 breastplate, aegis, egis +n02906734 broom +n02909870 bucket, pail +n02910353 buckle +n02916936 bulletproof vest +n02917067 bullet train, bullet +n02927161 butcher shop, meat market +n02930766 cab, hack, taxi, taxicab +n02939185 caldron, cauldron +n02948072 candle, taper, wax light +n02950826 cannon +n02951358 canoe +n02951585 can opener, tin opener +n02963159 cardigan +n02965783 car mirror +n02966193 carousel, carrousel, merry-go-round, roundabout, whirligig +n02966687 carpenter's kit, tool kit +n02971356 carton +n02974003 car wheel +n02977058 cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM +n02978881 cassette +n02979186 cassette player +n02980441 castle +n02981792 catamaran +n02988304 CD player +n02992211 cello, violoncello +n02992529 cellular telephone, cellular phone, cellphone, cell, mobile phone +n02999410 chain +n03000134 chainlink fence +n03000247 chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour +n03000684 chain saw, chainsaw +n03014705 chest +n03016953 chiffonier, commode +n03017168 chime, bell, gong +n03018349 china cabinet, china closet +n03026506 Christmas stocking +n03028079 church, church building +n03032252 cinema, movie theater, movie theatre, movie house, picture palace +n03041632 cleaver, meat cleaver, chopper +n03042490 cliff dwelling +n03045698 cloak +n03047690 clog, geta, patten, sabot +n03062245 cocktail shaker +n03063599 coffee mug +n03063689 coffeepot +n03065424 coil, spiral, volute, whorl, helix +n03075370 combination lock +n03085013 computer keyboard, keypad +n03089624 confectionery, confectionary, candy store +n03095699 container ship, containership, container vessel +n03100240 convertible +n03109150 corkscrew, bottle screw +n03110669 cornet, horn, trumpet, trump +n03124043 cowboy boot +n03124170 cowboy hat, ten-gallon hat +n03125729 cradle +n03126707 crane +n03127747 crash helmet +n03127925 crate +n03131574 crib, cot +n03133878 Crock Pot +n03134739 croquet ball +n03141823 crutch +n03146219 cuirass +n03160309 dam, dike, dyke +n03179701 desk +n03180011 desktop computer +n03187595 dial telephone, dial phone +n03188531 diaper, nappy, napkin +n03196217 digital clock +n03197337 digital watch +n03201208 dining table, board +n03207743 dishrag, dishcloth +n03207941 dishwasher, dish washer, dishwashing machine +n03208938 disk brake, disc brake +n03216828 dock, dockage, docking facility +n03218198 dogsled, dog sled, dog sleigh +n03220513 dome +n03223299 doormat, welcome mat +n03240683 drilling platform, offshore rig +n03249569 drum, membranophone, tympan +n03250847 drumstick +n03255030 dumbbell +n03259280 Dutch oven +n03271574 electric fan, blower +n03272010 electric guitar +n03272562 electric locomotive +n03290653 entertainment center +n03291819 envelope +n03297495 espresso maker +n03314780 face powder +n03325584 feather boa, boa +n03337140 file, file cabinet, filing cabinet +n03344393 fireboat +n03345487 fire engine, fire truck +n03347037 fire screen, fireguard +n03355925 flagpole, flagstaff +n03372029 flute, transverse flute +n03376595 folding chair +n03379051 football helmet +n03384352 forklift +n03388043 fountain +n03388183 fountain pen +n03388549 four-poster +n03393912 freight car +n03394916 French horn, horn +n03400231 frying pan, frypan, skillet +n03404251 fur coat +n03417042 garbage truck, dustcart +n03424325 gasmask, respirator, gas helmet +n03425413 gas pump, gasoline pump, petrol pump, island dispenser +n03443371 goblet +n03444034 go-kart +n03445777 golf ball +n03445924 golfcart, golf cart +n03447447 gondola +n03447721 gong, tam-tam +n03450230 gown +n03452741 grand piano, grand +n03457902 greenhouse, nursery, glasshouse +n03459775 grille, radiator grille +n03461385 grocery store, grocery, food market, market +n03467068 guillotine +n03476684 hair slide +n03476991 hair spray +n03478589 half track +n03481172 hammer +n03482405 hamper +n03483316 hand blower, blow dryer, blow drier, hair dryer, hair drier +n03485407 hand-held computer, hand-held microcomputer +n03485794 handkerchief, hankie, hanky, hankey +n03492542 hard disc, hard disk, fixed disk +n03494278 harmonica, mouth organ, harp, mouth harp +n03495258 harp +n03496892 harvester, reaper +n03498962 hatchet +n03527444 holster +n03529860 home theater, home theatre +n03530642 honeycomb +n03532672 hook, claw +n03534580 hoopskirt, crinoline +n03535780 horizontal bar, high bar +n03538406 horse cart, horse-cart +n03544143 hourglass +n03584254 iPod +n03584829 iron, smoothing iron +n03590841 jack-o'-lantern +n03594734 jean, blue jean, denim +n03594945 jeep, landrover +n03595614 jersey, T-shirt, tee shirt +n03598930 jigsaw puzzle +n03599486 jinrikisha, ricksha, rickshaw +n03602883 joystick +n03617480 kimono +n03623198 knee pad +n03627232 knot +n03630383 lab coat, laboratory coat +n03633091 ladle +n03637318 lampshade, lamp shade +n03642806 laptop, laptop computer +n03649909 lawn mower, mower +n03657121 lens cap, lens cover +n03658185 letter opener, paper knife, paperknife +n03661043 library +n03662601 lifeboat +n03666591 lighter, light, igniter, ignitor +n03670208 limousine, limo +n03673027 liner, ocean liner +n03676483 lipstick, lip rouge +n03680355 Loafer +n03690938 lotion +n03691459 loudspeaker, speaker, speaker unit, loudspeaker system, speaker system +n03692522 loupe, jeweler's loupe +n03697007 lumbermill, sawmill +n03706229 magnetic compass +n03709823 mailbag, postbag +n03710193 mailbox, letter box +n03710637 maillot +n03710721 maillot, tank suit +n03717622 manhole cover +n03720891 maraca +n03721384 marimba, xylophone +n03724870 mask +n03729826 matchstick +n03733131 maypole +n03733281 maze, labyrinth +n03733805 measuring cup +n03742115 medicine chest, medicine cabinet +n03743016 megalith, megalithic structure +n03759954 microphone, mike +n03761084 microwave, microwave oven +n03763968 military uniform +n03764736 milk can +n03769881 minibus +n03770439 miniskirt, mini +n03770679 minivan +n03773504 missile +n03775071 mitten +n03775546 mixing bowl +n03776460 mobile home, manufactured home +n03777568 Model T +n03777754 modem +n03781244 monastery +n03782006 monitor +n03785016 moped +n03786901 mortar +n03787032 mortarboard +n03788195 mosque +n03788365 mosquito net +n03791053 motor scooter, scooter +n03792782 mountain bike, all-terrain bike, off-roader +n03792972 mountain tent +n03793489 mouse, computer mouse +n03794056 mousetrap +n03796401 moving van +n03803284 muzzle +n03804744 nail +n03814639 neck brace +n03814906 necklace +n03825788 nipple +n03832673 notebook, notebook computer +n03837869 obelisk +n03838899 oboe, hautboy, hautbois +n03840681 ocarina, sweet potato +n03841143 odometer, hodometer, mileometer, milometer +n03843555 oil filter +n03854065 organ, pipe organ +n03857828 oscilloscope, scope, cathode-ray oscilloscope, CRO +n03866082 overskirt +n03868242 oxcart +n03868863 oxygen mask +n03871628 packet +n03873416 paddle, boat paddle +n03874293 paddlewheel, paddle wheel +n03874599 padlock +n03876231 paintbrush +n03877472 pajama, pyjama, pj's, jammies +n03877845 palace +n03884397 panpipe, pandean pipe, syrinx +n03887697 paper towel +n03888257 parachute, chute +n03888605 parallel bars, bars +n03891251 park bench +n03891332 parking meter +n03895866 passenger car, coach, carriage +n03899768 patio, terrace +n03902125 pay-phone, pay-station +n03903868 pedestal, plinth, footstall +n03908618 pencil box, pencil case +n03908714 pencil sharpener +n03916031 perfume, essence +n03920288 Petri dish +n03924679 photocopier +n03929660 pick, plectrum, plectron +n03929855 pickelhaube +n03930313 picket fence, paling +n03930630 pickup, pickup truck +n03933933 pier +n03935335 piggy bank, penny bank +n03937543 pill bottle +n03938244 pillow +n03942813 ping-pong ball +n03944341 pinwheel +n03947888 pirate, pirate ship +n03950228 pitcher, ewer +n03954731 plane, carpenter's plane, woodworking plane +n03956157 planetarium +n03958227 plastic bag +n03961711 plate rack +n03967562 plow, plough +n03970156 plunger, plumber's helper +n03976467 Polaroid camera, Polaroid Land camera +n03976657 pole +n03977966 police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria +n03980874 poncho +n03982430 pool table, billiard table, snooker table +n03983396 pop bottle, soda bottle +n03991062 pot, flowerpot +n03992509 potter's wheel +n03995372 power drill +n03998194 prayer rug, prayer mat +n04004767 printer +n04005630 prison, prison house +n04008634 projectile, missile +n04009552 projector +n04019541 puck, hockey puck +n04023962 punching bag, punch bag, punching ball, punchball +n04026417 purse +n04033901 quill, quill pen +n04033995 quilt, comforter, comfort, puff +n04037443 racer, race car, racing car +n04039381 racket, racquet +n04040759 radiator +n04041544 radio, wireless +n04044716 radio telescope, radio reflector +n04049303 rain barrel +n04065272 recreational vehicle, RV, R.V. +n04067472 reel +n04069434 reflex camera +n04070727 refrigerator, icebox +n04074963 remote control, remote +n04081281 restaurant, eating house, eating place, eatery +n04086273 revolver, six-gun, six-shooter +n04090263 rifle +n04099969 rocking chair, rocker +n04111531 rotisserie +n04116512 rubber eraser, rubber, pencil eraser +n04118538 rugby ball +n04118776 rule, ruler +n04120489 running shoe +n04125021 safe +n04127249 safety pin +n04131690 saltshaker, salt shaker +n04133789 sandal +n04136333 sarong +n04141076 sax, saxophone +n04141327 scabbard +n04141975 scale, weighing machine +n04146614 school bus +n04147183 schooner +n04149813 scoreboard +n04152593 screen, CRT screen +n04153751 screw +n04154565 screwdriver +n04162706 seat belt, seatbelt +n04179913 sewing machine +n04192698 shield, buckler +n04200800 shoe shop, shoe-shop, shoe store +n04201297 shoji +n04204238 shopping basket +n04204347 shopping cart +n04208210 shovel +n04209133 shower cap +n04209239 shower curtain +n04228054 ski +n04229816 ski mask +n04235860 sleeping bag +n04238763 slide rule, slipstick +n04239074 sliding door +n04243546 slot, one-armed bandit +n04251144 snorkel +n04252077 snowmobile +n04252225 snowplow, snowplough +n04254120 soap dispenser +n04254680 soccer ball +n04254777 sock +n04258138 solar dish, solar collector, solar furnace +n04259630 sombrero +n04263257 soup bowl +n04264628 space bar +n04265275 space heater +n04266014 space shuttle +n04270147 spatula +n04273569 speedboat +n04275548 spider web, spider's web +n04277352 spindle +n04285008 sports car, sport car +n04286575 spotlight, spot +n04296562 stage +n04310018 steam locomotive +n04311004 steel arch bridge +n04311174 steel drum +n04317175 stethoscope +n04325704 stole +n04326547 stone wall +n04328186 stopwatch, stop watch +n04330267 stove +n04332243 strainer +n04335435 streetcar, tram, tramcar, trolley, trolley car +n04336792 stretcher +n04344873 studio couch, day bed +n04346328 stupa, tope +n04347754 submarine, pigboat, sub, U-boat +n04350905 suit, suit of clothes +n04355338 sundial +n04355933 sunglass +n04356056 sunglasses, dark glasses, shades +n04357314 sunscreen, sunblock, sun blocker +n04366367 suspension bridge +n04367480 swab, swob, mop +n04370456 sweatshirt +n04371430 swimming trunks, bathing trunks +n04371774 swing +n04372370 switch, electric switch, electrical switch +n04376876 syringe +n04380533 table lamp +n04389033 tank, army tank, armored combat vehicle, armoured combat vehicle +n04392985 tape player +n04398044 teapot +n04399382 teddy, teddy bear +n04404412 television, television system +n04409515 tennis ball +n04417672 thatch, thatched roof +n04418357 theater curtain, theatre curtain +n04423845 thimble +n04428191 thresher, thrasher, threshing machine +n04429376 throne +n04435653 tile roof +n04442312 toaster +n04443257 tobacco shop, tobacconist shop, tobacconist +n04447861 toilet seat +n04456115 torch +n04458633 totem pole +n04461696 tow truck, tow car, wrecker +n04462240 toyshop +n04465501 tractor +n04467665 trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi +n04476259 tray +n04479046 trench coat +n04482393 tricycle, trike, velocipede +n04483307 trimaran +n04485082 tripod +n04486054 triumphal arch +n04487081 trolleybus, trolley coach, trackless trolley +n04487394 trombone +n04493381 tub, vat +n04501370 turnstile +n04505470 typewriter keyboard +n04507155 umbrella +n04509417 unicycle, monocycle +n04515003 upright, upright piano +n04517823 vacuum, vacuum cleaner +n04522168 vase +n04523525 vault +n04525038 velvet +n04525305 vending machine +n04532106 vestment +n04532670 viaduct +n04536866 violin, fiddle +n04540053 volleyball +n04542943 waffle iron +n04548280 wall clock +n04548362 wallet, billfold, notecase, pocketbook +n04550184 wardrobe, closet, press +n04552348 warplane, military plane +n04553703 washbasin, handbasin, washbowl, lavabo, wash-hand basin +n04554684 washer, automatic washer, washing machine +n04557648 water bottle +n04560804 water jug +n04562935 water tower +n04579145 whiskey jug +n04579432 whistle +n04584207 wig +n04589890 window screen +n04590129 window shade +n04591157 Windsor tie +n04591713 wine bottle +n04592741 wing +n04596742 wok +n04597913 wooden spoon +n04599235 wool, woolen, woollen +n04604644 worm fence, snake fence, snake-rail fence, Virginia fence +n04606251 wreck +n04612504 yawl +n04613696 yurt +n06359193 web site, website, internet site, site +n06596364 comic book +n06785654 crossword puzzle, crossword +n06794110 street sign +n06874185 traffic light, traffic signal, stoplight +n07248320 book jacket, dust cover, dust jacket, dust wrapper +n07565083 menu +n07579787 plate +n07583066 guacamole +n07584110 consomme +n07590611 hot pot, hotpot +n07613480 trifle +n07614500 ice cream, icecream +n07615774 ice lolly, lolly, lollipop, popsicle +n07684084 French loaf +n07693725 bagel, beigel +n07695742 pretzel +n07697313 cheeseburger +n07697537 hotdog, hot dog, red hot +n07711569 mashed potato +n07714571 head cabbage +n07714990 broccoli +n07715103 cauliflower +n07716358 zucchini, courgette +n07716906 spaghetti squash +n07717410 acorn squash +n07717556 butternut squash +n07718472 cucumber, cuke +n07718747 artichoke, globe artichoke +n07720875 bell pepper +n07730033 cardoon +n07734744 mushroom +n07742313 Granny Smith +n07745940 strawberry +n07747607 orange +n07749582 lemon +n07753113 fig +n07753275 pineapple, ananas +n07753592 banana +n07754684 jackfruit, jak, jack +n07760859 custard apple +n07768694 pomegranate +n07802026 hay +n07831146 carbonara +n07836838 chocolate sauce, chocolate syrup +n07860988 dough +n07871810 meat loaf, meatloaf +n07873807 pizza, pizza pie +n07875152 potpie +n07880968 burrito +n07892512 red wine +n07920052 espresso +n07930864 cup +n07932039 eggnog +n09193705 alp +n09229709 bubble +n09246464 cliff, drop, drop-off +n09256479 coral reef +n09288635 geyser +n09332890 lakeside, lakeshore +n09399592 promontory, headland, head, foreland +n09421951 sandbar, sand bar +n09428293 seashore, coast, seacoast, sea-coast +n09468604 valley, vale +n09472597 volcano +n09835506 ballplayer, baseball player +n10148035 groom, bridegroom +n10565667 scuba diver +n11879895 rapeseed +n11939491 daisy +n12057211 yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum +n12144580 corn +n12267677 acorn +n12620546 hip, rose hip, rosehip +n12768682 buckeye, horse chestnut, conker +n12985857 coral fungus +n12998815 agaric +n13037406 gyromitra +n13040303 stinkhorn, carrion fungus +n13044778 earthstar +n13052670 hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa +n13054560 bolete +n13133613 ear, spike, capitulum +n15075141 toilet tissue, toilet paper, bathroom tissue diff --git a/modules/dnn/samples/tf_inception.cpp b/modules/dnn/samples/tf_inception.cpp new file mode 100644 index 0000000000..44af4ce8ee --- /dev/null +++ b/modules/dnn/samples/tf_inception.cpp @@ -0,0 +1,173 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Sample of using OpenCV dnn module with Tensorflow Inception model. +*/ + +#include +#include +#include +using namespace cv; +using namespace cv::dnn; + +#include +#include +#include +using namespace std; + +const String keys = + "{help h || Sample app for loading Inception TensorFlow model. " + "The model and class names list can be downloaded here: " + "https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip }" + "{model m |tensorflow_inception_graph.pb| path to TensorFlow .pb model file }" + "{image i || path to image file }" + "{i_blob | input | input blob name) }" + "{o_blob | softmax2 | output blob name) }" + "{c_names c | imagenet_comp_graph_label_strings.txt | path to file with classnames for class id }" + "{result r || path to save output blob (optional, binary format, NCHW order) }" + ; + +void getMaxClass(const Mat &probBlob, int *classId, double *classProb); +std::vector readClassNames(const char *filename); + +int main(int argc, char **argv) +{ + cv::CommandLineParser parser(argc, argv, keys); + + if (parser.has("help")) + { + parser.printMessage(); + return 0; + } + + String modelFile = parser.get("model"); + String imageFile = parser.get("image"); + String inBlobName = parser.get("i_blob"); + String outBlobName = parser.get("o_blob"); + + if (!parser.check()) + { + parser.printErrors(); + return 0; + } + + String classNamesFile = parser.get("c_names"); + String resultFile = parser.get("result"); + + //! [Create the importer of TensorFlow model] + Ptr importer; + try //Try to import TensorFlow AlexNet model + { + importer = dnn::createTensorflowImporter(modelFile); + } + catch (const cv::Exception &err) //Importer can throw errors, we will catch them + { + std::cerr << err.msg << std::endl; + } + //! [Create the importer of Caffe model] + + if (!importer) + { + std::cerr << "Can't load network by using the mode file: " << std::endl; + std::cerr << modelFile << std::endl; + exit(-1); + } + + //! [Initialize network] + dnn::Net net; + importer->populateNet(net); + importer.release(); //We don't need importer anymore + //! [Initialize network] + + //! [Prepare blob] + Mat img = imread(imageFile); + if (img.empty()) + { + std::cerr << "Can't read image from the file: " << imageFile << std::endl; + exit(-1); + } + + cv::Size inputImgSize = cv::Size(224, 224); + + if (inputImgSize != img.size()) + resize(img, img, inputImgSize); //Resize image to input size + + Mat inputBlob = blobFromImage(img); //Convert Mat to image batch + //! [Prepare blob] + inputBlob -= 117.0; + //! [Set input blob] + net.setInput(inputBlob, inBlobName); //set the network input + //! [Set input blob] + + cv::TickMeter tm; + tm.start(); + + //! [Make forward pass] + Mat result = net.forward(outBlobName); //compute output + //! [Make forward pass] + + tm.stop(); + + if (!resultFile.empty()) { + CV_Assert(result.isContinuous()); + + ofstream fout(resultFile.c_str(), ios::out | ios::binary); + fout.write((char*)result.data, result.total() * sizeof(float)); + fout.close(); + } + + std::cout << "Output blob shape " << result.size[0] << " x " << result.size[1] << " x " << result.size[2] << " x " << result.size[3] << std::endl; + std::cout << "Inference time, ms: " << tm.getTimeMilli() << std::endl; + + if (!classNamesFile.empty()) { + std::vector classNames = readClassNames(classNamesFile.c_str()); + + int classId; + double classProb; + getMaxClass(result, &classId, &classProb);//find the best class + + //! [Print results] + std::cout << "Best class: #" << classId << " '" << classNames.at(classId) << "'" << std::endl; + std::cout << "Probability: " << classProb * 100 << "%" << std::endl; + } + return 0; +} //main + + +/* Find best class for the blob (i. e. class with maximal probability) */ +void getMaxClass(const Mat &probBlob, int *classId, double *classProb) +{ + Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix + Point classNumber; + + minMaxLoc(probMat, NULL, classProb, NULL, &classNumber); + *classId = classNumber.x; +} + +std::vector readClassNames(const char *filename) +{ + std::vector classNames; + + std::ifstream fp(filename); + if (!fp.is_open()) + { + std::cerr << "File with classes labels not found: " << filename << std::endl; + exit(-1); + } + + std::string name; + while (!fp.eof()) + { + std::getline(fp, name); + if (name.length()) + classNames.push_back( name ); + } + + fp.close(); + return classNames; +} diff --git a/modules/dnn/samples/torch_enet.cpp b/modules/dnn/samples/torch_enet.cpp new file mode 100644 index 0000000000..1b46e5a058 --- /dev/null +++ b/modules/dnn/samples/torch_enet.cpp @@ -0,0 +1,207 @@ +/* +Sample of using OpenCV dnn module with Torch ENet model. +*/ + +#include +#include +#include +using namespace cv; +using namespace cv::dnn; + +#include +#include +#include +#include +using namespace std; + +const String keys = + "{help h || Sample app for loading ENet Torch model. " + "The model and class names list can be downloaded here: " + "https://www.dropbox.com/sh/dywzk3gyb12hpe5/AAD5YkUa8XgMpHs2gCRgmCVCa }" + "{model m || path to Torch .net model file (model_best.net) }" + "{image i || path to image file }" + "{c_names c || path to file with classnames for channels (optional, categories.txt) }" + "{result r || path to save output blob (optional, binary format, NCHW order) }" + "{show s || whether to show all output channels or not}" + "{o_blob || output blob's name. If empty, last blob's name in net is used}" + ; + +static void colorizeSegmentation(const Mat &score, Mat &segm, + Mat &legend, vector &classNames, vector &colors); +static vector readColors(const String &filename, vector& classNames); + +int main(int argc, char **argv) +{ + CommandLineParser parser(argc, argv, keys); + + if (parser.has("help")) + { + parser.printMessage(); + return 0; + } + + String modelFile = parser.get("model"); + String imageFile = parser.get("image"); + + if (!parser.check()) + { + parser.printErrors(); + return 0; + } + + String classNamesFile = parser.get("c_names"); + String resultFile = parser.get("result"); + + //! [Read model and initialize network] + dnn::Net net = dnn::readNetFromTorch(modelFile); + + //! [Prepare blob] + Mat img = imread(imageFile), input; + if (img.empty()) + { + std::cerr << "Can't read image from the file: " << imageFile << std::endl; + exit(-1); + } + + Size origSize = img.size(); + Size inputImgSize = cv::Size(1024, 512); + + if (inputImgSize != origSize) + resize(img, img, inputImgSize); //Resize image to input size + + Mat inputBlob = blobFromImage(img, 1./255); //Convert Mat to image batch + //! [Prepare blob] + + //! [Set input blob] + net.setInput(inputBlob, ""); //set the network input + //! [Set input blob] + + TickMeter tm; + + String oBlob = net.getLayerNames().back(); + if (!parser.get("o_blob").empty()) + { + oBlob = parser.get("o_blob"); + } + + //! [Make forward pass] + Mat result = net.forward(oBlob); + + if (!resultFile.empty()) { + CV_Assert(result.isContinuous()); + + ofstream fout(resultFile.c_str(), ios::out | ios::binary); + fout.write((char*)result.data, result.total() * sizeof(float)); + fout.close(); + } + + std::cout << "Output blob: " << result.size[0] << " x " << result.size[1] << " x " << result.size[2] << " x " << result.size[3] << "\n"; + std::cout << "Inference time, ms: " << tm.getTimeMilli() << std::endl; + + if (parser.has("show")) + { + std::vector classNames; + vector colors; + if(!classNamesFile.empty()) { + colors = readColors(classNamesFile, classNames); + } + Mat segm, legend; + colorizeSegmentation(result, segm, legend, classNames, colors); + + Mat show; + addWeighted(img, 0.1, segm, 0.9, 0.0, show); + + cv::resize(show, show, origSize, 0, 0, cv::INTER_NEAREST); + imshow("Result", show); + if(classNames.size()) + imshow("Legend", legend); + waitKey(); + } + + return 0; +} //main + +static void colorizeSegmentation(const Mat &score, Mat &segm, Mat &legend, vector &classNames, vector &colors) +{ + const int rows = score.size[2]; + const int cols = score.size[3]; + const int chns = score.size[1]; + + cv::Mat maxCl(rows, cols, CV_8UC1); + cv::Mat maxVal(rows, cols, CV_32FC1); + for (int ch = 0; ch < chns; ch++) + { + for (int row = 0; row < rows; row++) + { + const float *ptrScore = score.ptr(0, ch, row); + uchar *ptrMaxCl = maxCl.ptr(row); + float *ptrMaxVal = maxVal.ptr(row); + for (int col = 0; col < cols; col++) + { + if (ptrScore[col] > ptrMaxVal[col]) + { + ptrMaxVal[col] = ptrScore[col]; + ptrMaxCl[col] = ch; + } + } + } + } + + segm.create(rows, cols, CV_8UC3); + for (int row = 0; row < rows; row++) + { + const uchar *ptrMaxCl = maxCl.ptr(row); + cv::Vec3b *ptrSegm = segm.ptr(row); + for (int col = 0; col < cols; col++) + { + ptrSegm[col] = colors[ptrMaxCl[col]]; + } + } + + if (classNames.size() == colors.size()) + { + int blockHeight = 30; + legend.create(blockHeight*classNames.size(), 200, CV_8UC3); + for(int i = 0; i < classNames.size(); i++) + { + cv::Mat block = legend.rowRange(i*blockHeight, (i+1)*blockHeight); + block = colors[i]; + putText(block, classNames[i], Point(0, blockHeight/2), FONT_HERSHEY_SIMPLEX, 0.5, Scalar()); + } + } +} + +static vector readColors(const String &filename, vector& classNames) +{ + vector colors; + classNames.clear(); + + ifstream fp(filename.c_str()); + if (!fp.is_open()) + { + cerr << "File with colors not found: " << filename << endl; + exit(-1); + } + + string line; + while (!fp.eof()) + { + getline(fp, line); + if (line.length()) + { + stringstream ss(line); + + string name; ss >> name; + int temp; + cv::Vec3b color; + ss >> temp; color[0] = temp; + ss >> temp; color[1] = temp; + ss >> temp; color[2] = temp; + classNames.push_back(name); + colors.push_back(color); + } + } + + fp.close(); + return colors; +} diff --git a/modules/dnn/src/caffe/caffe.proto b/modules/dnn/src/caffe/caffe.proto new file mode 100644 index 0000000000..3d23fb48ea --- /dev/null +++ b/modules/dnn/src/caffe/caffe.proto @@ -0,0 +1,1581 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +//COPYRIGHT +// +//All contributions by the University of California: +//Copyright (c) 2014, The Regents of the University of California (Regents) +//All rights reserved. +// +//All other contributions: +//Copyright (c) 2014, the respective contributors +//All rights reserved. +// +//Caffe uses a shared copyright model: each contributor holds copyright over +//their contributions to Caffe. The project versioning records all such +//contribution and copyright details. If a contributor wants to further mark +//their specific copyright on a particular contribution, they should indicate +//their copyright solely in the commit message of the change when it is +//committed. +// +//LICENSE +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions are met: +// +//1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +//2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//CONTRIBUTION AGREEMENT +// +//By contributing to the BVLC/caffe repository through pull-request, comment, +//or otherwise, the contributor releases their content to the +//license and copyright terms herein. +// +//M*/ + +syntax = "proto2"; + +package caffe; + +// Specifies the shape (dimensions) of a Blob. +message BlobShape { + repeated int64 dim = 1 [packed = true]; +} + +message BlobProto { + optional BlobShape shape = 7; + repeated float data = 5 [packed = true]; + repeated float diff = 6 [packed = true]; + repeated double double_data = 8 [packed = true]; + repeated double double_diff = 9 [packed = true]; + + // 4D dimensions -- deprecated. Use "shape" instead. + optional int32 num = 1 [default = 0]; + optional int32 channels = 2 [default = 0]; + optional int32 height = 3 [default = 0]; + optional int32 width = 4 [default = 0]; +} + +// The BlobProtoVector is simply a way to pass multiple blobproto instances +// around. +message BlobProtoVector { + repeated BlobProto blobs = 1; +} + +message PermuteParameter { + // The new orders of the axes of data. Notice it should be with + // in the same range as the input data, and it starts from 0. + // Do not provide repeated order. + repeated uint32 order = 1; +} + +// Message that stores parameters used by NormalizeBBoxLayer +message NormalizeBBoxParameter { + optional bool across_spatial = 1 [default = true]; + // Initial value of scale. Default is 1.0 for all + optional FillerParameter scale_filler = 2; + // Whether or not scale parameters are shared across channels. + optional bool channel_shared = 3 [default = true]; + // Epsilon for not dividing by zero while normalizing variance + optional float eps = 4 [default = 1e-10]; +} + +// Message that store parameters used by PriorBoxLayer +message PriorBoxParameter { + // Encode/decode type. + enum CodeType { + CORNER = 1; + CENTER_SIZE = 2; + } + // Minimum box size (in pixels). Required! + optional float min_size = 1; + // Maximum box size (in pixels). Required! + optional float max_size = 2; + // Various of aspect ratios. Duplicate ratios will be ignored. + // If none is provided, we use default ratio 1. + repeated float aspect_ratio = 3; + // If true, will flip each aspect ratio. + // For example, if there is aspect ratio "r", + // we will generate aspect ratio "1.0/r" as well. + optional bool flip = 4 [default = true]; + // If true, will clip the prior so that it is within [0, 1] + optional bool clip = 5 [default = true]; + // Variance for adjusting the prior bboxes. + repeated float variance = 6; + // By default, we calculate img_height, img_width, step_x, step_y based on + // bottom[0] (feat) and bottom[1] (img). Unless these values are explicitely + // provided. + // Explicitly provide the img_size. + optional uint32 img_size = 7; + // Either img_size or img_h/img_w should be specified; not both. + optional uint32 img_h = 8; + optional uint32 img_w = 9; + // Explicitly provide the step size. + optional float step = 10; + // Either step or step_h/step_w should be specified; not both. + optional float step_h = 11; + optional float step_w = 12; + // Offset to the top left corner of each cell. + optional float offset = 13 [default = 0.5]; +} + +// Message that store parameters used by DetectionOutputLayer +message DetectionOutputParameter { + // Number of classes to be predicted. Required! + optional uint32 num_classes = 1; + // If true, bounding box are shared among different classes. + optional bool share_location = 2 [default = true]; + // Background label id. If there is no background class, + // set it as -1. + optional int32 background_label_id = 3 [default = 0]; + // Parameters used for non maximum suppression. + optional NonMaximumSuppressionParameter nms_param = 4; + // Parameters used for saving detection results. + optional SaveOutputParameter save_output_param = 5; + // Type of coding method for bbox. + optional PriorBoxParameter.CodeType code_type = 6 [default = CORNER]; + // If true, variance is encoded in target; otherwise we need to adjust the + // predicted offset accordingly. + optional bool variance_encoded_in_target = 8 [default = false]; + // Number of total bboxes to be kept per image after nms step. + // -1 means keeping all bboxes after nms step. + optional int32 keep_top_k = 7 [default = -1]; + // Only consider detections whose confidences are larger than a threshold. + // If not provided, consider all boxes. + optional float confidence_threshold = 9; +} + +message Datum { + optional int32 channels = 1; + optional int32 height = 2; + optional int32 width = 3; + // the actual image data, in bytes + optional bytes data = 4; + optional int32 label = 5; + // Optionally, the datum could also hold float data. + repeated float float_data = 6; + // If true data contains an encoded image that need to be decoded + optional bool encoded = 7 [default = false]; +} + +message FillerParameter { + // The filler type. + optional string type = 1 [default = 'constant']; + optional float value = 2 [default = 0]; // the value in constant filler + optional float min = 3 [default = 0]; // the min value in uniform filler + optional float max = 4 [default = 1]; // the max value in uniform filler + optional float mean = 5 [default = 0]; // the mean value in Gaussian filler + optional float std = 6 [default = 1]; // the std value in Gaussian filler + // The expected number of non-zero output weights for a given input in + // Gaussian filler -- the default -1 means don't perform sparsification. + optional int32 sparse = 7 [default = -1]; + // Normalize the filler variance by fan_in, fan_out, or their average. + // Applies to 'xavier' and 'msra' fillers. + enum VarianceNorm { + FAN_IN = 0; + FAN_OUT = 1; + AVERAGE = 2; + } + optional VarianceNorm variance_norm = 8 [default = FAN_IN]; +} + +message NetParameter { + optional string name = 1; // consider giving the network a name + // DEPRECATED. See InputParameter. The input blobs to the network. + repeated string input = 3; + // DEPRECATED. See InputParameter. The shape of the input blobs. + repeated BlobShape input_shape = 8; + + // 4D input dimensions -- deprecated. Use "input_shape" instead. + // If specified, for each input blob there should be four + // values specifying the num, channels, height and width of the input blob. + // Thus, there should be a total of (4 * #input) numbers. + repeated int32 input_dim = 4; + + // Whether the network will force every layer to carry out backward operation. + // If set False, then whether to carry out backward is determined + // automatically according to the net structure and learning rates. + optional bool force_backward = 5 [default = false]; + // The current "state" of the network, including the phase, level, and stage. + // Some layers may be included/excluded depending on this state and the states + // specified in the layers' include and exclude fields. + optional NetState state = 6; + + // Print debugging information about results while running Net::Forward, + // Net::Backward, and Net::Update. + optional bool debug_info = 7 [default = false]; + + // The layers that make up the net. Each of their configurations, including + // connectivity and behavior, is specified as a LayerParameter. + repeated LayerParameter layer = 100; // ID 100 so layers are printed last. + + // DEPRECATED: use 'layer' instead. + repeated V1LayerParameter layers = 2; +} + +// NOTE +// Update the next available ID when you add a new SolverParameter field. +// +// SolverParameter next available ID: 41 (last added: type) +message SolverParameter { + ////////////////////////////////////////////////////////////////////////////// + // Specifying the train and test networks + // + // Exactly one train net must be specified using one of the following fields: + // train_net_param, train_net, net_param, net + // One or more test nets may be specified using any of the following fields: + // test_net_param, test_net, net_param, net + // If more than one test net field is specified (e.g., both net and + // test_net are specified), they will be evaluated in the field order given + // above: (1) test_net_param, (2) test_net, (3) net_param/net. + // A test_iter must be specified for each test_net. + // A test_level and/or a test_stage may also be specified for each test_net. + ////////////////////////////////////////////////////////////////////////////// + + // Proto filename for the train net, possibly combined with one or more + // test nets. + optional string net = 24; + // Inline train net param, possibly combined with one or more test nets. + optional NetParameter net_param = 25; + + optional string train_net = 1; // Proto filename for the train net. + repeated string test_net = 2; // Proto filenames for the test nets. + optional NetParameter train_net_param = 21; // Inline train net params. + repeated NetParameter test_net_param = 22; // Inline test net params. + + // The states for the train/test nets. Must be unspecified or + // specified once per net. + // + // By default, all states will have solver = true; + // train_state will have phase = TRAIN, + // and all test_state's will have phase = TEST. + // Other defaults are set according to the NetState defaults. + optional NetState train_state = 26; + repeated NetState test_state = 27; + + // The number of iterations for each test net. + repeated int32 test_iter = 3; + + // The number of iterations between two testing phases. + optional int32 test_interval = 4 [default = 0]; + optional bool test_compute_loss = 19 [default = false]; + // If true, run an initial test pass before the first iteration, + // ensuring memory availability and printing the starting value of the loss. + optional bool test_initialization = 32 [default = true]; + optional float base_lr = 5; // The base learning rate + // the number of iterations between displaying info. If display = 0, no info + // will be displayed. + optional int32 display = 6; + // Display the loss averaged over the last average_loss iterations + optional int32 average_loss = 33 [default = 1]; + optional int32 max_iter = 7; // the maximum number of iterations + // accumulate gradients over `iter_size` x `batch_size` instances + optional int32 iter_size = 36 [default = 1]; + + // The learning rate decay policy. The currently implemented learning rate + // policies are as follows: + // - fixed: always return base_lr. + // - step: return base_lr * gamma ^ (floor(iter / step)) + // - exp: return base_lr * gamma ^ iter + // - inv: return base_lr * (1 + gamma * iter) ^ (- power) + // - multistep: similar to step but it allows non uniform steps defined by + // stepvalue + // - poly: the effective learning rate follows a polynomial decay, to be + // zero by the max_iter. return base_lr (1 - iter/max_iter) ^ (power) + // - sigmoid: the effective learning rate follows a sigmod decay + // return base_lr ( 1/(1 + exp(-gamma * (iter - stepsize)))) + // + // where base_lr, max_iter, gamma, step, stepvalue and power are defined + // in the solver parameter protocol buffer, and iter is the current iteration. + optional string lr_policy = 8; + optional float gamma = 9; // The parameter to compute the learning rate. + optional float power = 10; // The parameter to compute the learning rate. + optional float momentum = 11; // The momentum value. + optional float weight_decay = 12; // The weight decay. + // regularization types supported: L1 and L2 + // controlled by weight_decay + optional string regularization_type = 29 [default = "L2"]; + // the stepsize for learning rate policy "step" + optional int32 stepsize = 13; + // the stepsize for learning rate policy "multistep" + repeated int32 stepvalue = 34; + + // Set clip_gradients to >= 0 to clip parameter gradients to that L2 norm, + // whenever their actual L2 norm is larger. + optional float clip_gradients = 35 [default = -1]; + + optional int32 snapshot = 14 [default = 0]; // The snapshot interval + optional string snapshot_prefix = 15; // The prefix for the snapshot. + // whether to snapshot diff in the results or not. Snapshotting diff will help + // debugging but the final protocol buffer size will be much larger. + optional bool snapshot_diff = 16 [default = false]; + enum SnapshotFormat { + HDF5 = 0; + BINARYPROTO = 1; + } + optional SnapshotFormat snapshot_format = 37 [default = BINARYPROTO]; + // the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default. + enum SolverMode { + CPU = 0; + GPU = 1; + } + optional SolverMode solver_mode = 17 [default = GPU]; + // the device_id will that be used in GPU mode. Use device_id = 0 in default. + optional int32 device_id = 18 [default = 0]; + // If non-negative, the seed with which the Solver will initialize the Caffe + // random number generator -- useful for reproducible results. Otherwise, + // (and by default) initialize using a seed derived from the system clock. + optional int64 random_seed = 20 [default = -1]; + + // type of the solver + optional string type = 40 [default = "SGD"]; + + // numerical stability for RMSProp, AdaGrad and AdaDelta and Adam + optional float delta = 31 [default = 1e-8]; + // parameters for the Adam solver + optional float momentum2 = 39 [default = 0.999]; + + // RMSProp decay value + // MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t) + optional float rms_decay = 38 [default = 0.99]; + + // If true, print information about the state of the net that may help with + // debugging learning problems. + optional bool debug_info = 23 [default = false]; + + // If false, don't save a snapshot after training finishes. + optional bool snapshot_after_train = 28 [default = true]; + + // DEPRECATED: old solver enum types, use string instead + enum SolverType { + SGD = 0; + NESTEROV = 1; + ADAGRAD = 2; + RMSPROP = 3; + ADADELTA = 4; + ADAM = 5; + } + // DEPRECATED: use type instead of solver_type + optional SolverType solver_type = 30 [default = SGD]; +} + +// A message that stores the solver snapshots +message SolverState { + optional int32 iter = 1; // The current iteration + optional string learned_net = 2; // The file that stores the learned net. + repeated BlobProto history = 3; // The history for sgd solvers + optional int32 current_step = 4 [default = 0]; // The current step for learning rate +} + +enum Phase { + TRAIN = 0; + TEST = 1; +} + +message NetState { + optional Phase phase = 1 [default = TEST]; + optional int32 level = 2 [default = 0]; + repeated string stage = 3; +} + +message NetStateRule { + // Set phase to require the NetState have a particular phase (TRAIN or TEST) + // to meet this rule. + optional Phase phase = 1; + + // Set the minimum and/or maximum levels in which the layer should be used. + // Leave undefined to meet the rule regardless of level. + optional int32 min_level = 2; + optional int32 max_level = 3; + + // Customizable sets of stages to include or exclude. + // The net must have ALL of the specified stages and NONE of the specified + // "not_stage"s to meet the rule. + // (Use multiple NetStateRules to specify conjunctions of stages.) + repeated string stage = 4; + repeated string not_stage = 5; +} + +// Specifies training parameters (multipliers on global learning constants, +// and the name and other settings used for weight sharing). +message ParamSpec { + // The names of the parameter blobs -- useful for sharing parameters among + // layers, but never required otherwise. To share a parameter between two + // layers, give it a (non-empty) name. + optional string name = 1; + + // Whether to require shared weights to have the same shape, or just the same + // count -- defaults to STRICT if unspecified. + optional DimCheckMode share_mode = 2; + enum DimCheckMode { + // STRICT (default) requires that num, channels, height, width each match. + STRICT = 0; + // PERMISSIVE requires only the count (num*channels*height*width) to match. + PERMISSIVE = 1; + } + + // The multiplier on the global learning rate for this parameter. + optional float lr_mult = 3 [default = 1.0]; + + // The multiplier on the global weight decay for this parameter. + optional float decay_mult = 4 [default = 1.0]; +} + +// NOTE +// Update the next available ID when you add a new LayerParameter field. +// +// LayerParameter next available layer-specific ID: 147 (last added: recurrent_param) +message LayerParameter { + optional string name = 1; // the layer name + optional string type = 2; // the layer type + repeated string bottom = 3; // the name of each bottom blob + repeated string top = 4; // the name of each top blob + + // The train / test phase for computation. + optional Phase phase = 10; + + // The amount of weight to assign each top blob in the objective. + // Each layer assigns a default value, usually of either 0 or 1, + // to each top blob. + repeated float loss_weight = 5; + + // Specifies training parameters (multipliers on global learning constants, + // and the name and other settings used for weight sharing). + repeated ParamSpec param = 6; + + // The blobs containing the numeric parameters of the layer. + repeated BlobProto blobs = 7; + + // Specifies whether to backpropagate to each bottom. If unspecified, + // Caffe will automatically infer whether each input needs backpropagation + // to compute parameter gradients. If set to true for some inputs, + // backpropagation to those inputs is forced; if set false for some inputs, + // backpropagation to those inputs is skipped. + // + // The size must be either 0 or equal to the number of bottoms. + repeated bool propagate_down = 11; + + // Rules controlling whether and when a layer is included in the network, + // based on the current NetState. You may specify a non-zero number of rules + // to include OR exclude, but not both. If no include or exclude rules are + // specified, the layer is always included. If the current NetState meets + // ANY (i.e., one or more) of the specified rules, the layer is + // included/excluded. + repeated NetStateRule include = 8; + repeated NetStateRule exclude = 9; + + // Parameters for data pre-processing. + optional TransformationParameter transform_param = 100; + + // Parameters shared by loss layers. + optional LossParameter loss_param = 101; + + // Layer type-specific parameters. + // + // Note: certain layers may have more than one computational engine + // for their implementation. These layers include an Engine type and + // engine parameter for selecting the implementation. + // The default for the engine is set by the ENGINE switch at compile-time. + optional AccuracyParameter accuracy_param = 102; + optional ArgMaxParameter argmax_param = 103; + optional BatchNormParameter batch_norm_param = 139; + optional BiasParameter bias_param = 141; + optional ConcatParameter concat_param = 104; + optional ContrastiveLossParameter contrastive_loss_param = 105; + optional ConvolutionParameter convolution_param = 106; + optional CropParameter crop_param = 144; + optional DataParameter data_param = 107; + optional DetectionOutputParameter detection_output_param = 147; + optional DropoutParameter dropout_param = 108; + optional DummyDataParameter dummy_data_param = 109; + optional EltwiseParameter eltwise_param = 110; + optional ELUParameter elu_param = 140; + optional EmbedParameter embed_param = 137; + optional ExpParameter exp_param = 111; + optional FlattenParameter flatten_param = 135; + optional HDF5DataParameter hdf5_data_param = 112; + optional HDF5OutputParameter hdf5_output_param = 113; + optional HingeLossParameter hinge_loss_param = 114; + optional ImageDataParameter image_data_param = 115; + optional InfogainLossParameter infogain_loss_param = 116; + optional InnerProductParameter inner_product_param = 117; + optional InputParameter input_param = 143; + optional LogParameter log_param = 134; + optional LRNParameter lrn_param = 118; + optional MemoryDataParameter memory_data_param = 119; + optional MVNParameter mvn_param = 120; + optional NormalizeBBoxParameter norm_param = 149; + optional PermuteParameter permute_param = 148; + optional ParameterParameter parameter_param = 145; + optional PoolingParameter pooling_param = 121; + optional PowerParameter power_param = 122; + optional PReLUParameter prelu_param = 131; + optional PriorBoxParameter prior_box_param = 150; + optional PythonParameter python_param = 130; + optional RecurrentParameter recurrent_param = 146; + optional ReductionParameter reduction_param = 136; + optional ReLUParameter relu_param = 123; + optional ReshapeParameter reshape_param = 133; + optional ScaleParameter scale_param = 142; + optional SigmoidParameter sigmoid_param = 124; + optional SoftmaxParameter softmax_param = 125; + optional SPPParameter spp_param = 132; + optional SliceParameter slice_param = 126; + optional TanHParameter tanh_param = 127; + optional ThresholdParameter threshold_param = 128; + optional TileParameter tile_param = 138; + optional WindowDataParameter window_data_param = 129; +} + +// Message that stores parameters used to apply transformation +// to the data layer's data +message TransformationParameter { + // For data pre-processing, we can do simple scaling and subtracting the + // data mean, if provided. Note that the mean subtraction is always carried + // out before scaling. + optional float scale = 1 [default = 1]; + // Specify if we want to randomly mirror data. + optional bool mirror = 2 [default = false]; + // Specify if we would like to randomly crop an image. + optional uint32 crop_size = 3 [default = 0]; + // mean_file and mean_value cannot be specified at the same time + optional string mean_file = 4; + // if specified can be repeated once (would subtract it from all the channels) + // or can be repeated the same number of times as channels + // (would subtract them from the corresponding channel) + repeated float mean_value = 5; + // Force the decoded image to have 3 color channels. + optional bool force_color = 6 [default = false]; + // Force the decoded image to have 1 color channels. + optional bool force_gray = 7 [default = false]; +} + +// Message that stores parameters shared by loss layers +message LossParameter { + // If specified, ignore instances with the given label. + optional int32 ignore_label = 1; + // How to normalize the loss for loss layers that aggregate across batches, + // spatial dimensions, or other dimensions. Currently only implemented in + // SoftmaxWithLoss and SigmoidCrossEntropyLoss layers. + enum NormalizationMode { + // Divide by the number of examples in the batch times spatial dimensions. + // Outputs that receive the ignore label will NOT be ignored in computing + // the normalization factor. + FULL = 0; + // Divide by the total number of output locations that do not take the + // ignore_label. If ignore_label is not set, this behaves like FULL. + VALID = 1; + // Divide by the batch size. + BATCH_SIZE = 2; + // Do not normalize the loss. + NONE = 3; + } + // For historical reasons, the default normalization for + // SigmoidCrossEntropyLoss is BATCH_SIZE and *not* VALID. + optional NormalizationMode normalization = 3 [default = VALID]; + // Deprecated. Ignored if normalization is specified. If normalization + // is not specified, then setting this to false will be equivalent to + // normalization = BATCH_SIZE to be consistent with previous behavior. + optional bool normalize = 2; +} + +// Messages that store parameters used by individual layer types follow, in +// alphabetical order. + +message AccuracyParameter { + // When computing accuracy, count as correct by comparing the true label to + // the top k scoring classes. By default, only compare to the top scoring + // class (i.e. argmax). + optional uint32 top_k = 1 [default = 1]; + + // The "label" axis of the prediction blob, whose argmax corresponds to the + // predicted label -- may be negative to index from the end (e.g., -1 for the + // last axis). For example, if axis == 1 and the predictions are + // (N x C x H x W), the label blob is expected to contain N*H*W ground truth + // labels with integer values in {0, 1, ..., C-1}. + optional int32 axis = 2 [default = 1]; + + // If specified, ignore instances with the given label. + optional int32 ignore_label = 3; +} + +message ArgMaxParameter { + // If true produce pairs (argmax, maxval) + optional bool out_max_val = 1 [default = false]; + optional uint32 top_k = 2 [default = 1]; + // The axis along which to maximise -- may be negative to index from the + // end (e.g., -1 for the last axis). + // By default ArgMaxLayer maximizes over the flattened trailing dimensions + // for each index of the first / num dimension. + optional int32 axis = 3; +} + +message ConcatParameter { + // The axis along which to concatenate -- may be negative to index from the + // end (e.g., -1 for the last axis). Other axes must have the + // same dimension for all the bottom blobs. + // By default, ConcatLayer concatenates blobs along the "channels" axis (1). + optional int32 axis = 2 [default = 1]; + + // DEPRECATED: alias for "axis" -- does not support negative indexing. + optional uint32 concat_dim = 1 [default = 1]; +} + +message BatchNormParameter { + // If false, accumulate global mean/variance values via a moving average. If + // true, use those accumulated values instead of computing mean/variance + // across the batch. + optional bool use_global_stats = 1; + // How much does the moving average decay each iteration? + optional float moving_average_fraction = 2 [default = .999]; + // Small value to add to the variance estimate so that we don't divide by + // zero. + optional float eps = 3 [default = 1e-5]; +} + +message BiasParameter { + // The first axis of bottom[0] (the first input Blob) along which to apply + // bottom[1] (the second input Blob). May be negative to index from the end + // (e.g., -1 for the last axis). + // + // For example, if bottom[0] is 4D with shape 100x3x40x60, the output + // top[0] will have the same shape, and bottom[1] may have any of the + // following shapes (for the given value of axis): + // (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60 + // (axis == 1 == -3) 3; 3x40; 3x40x60 + // (axis == 2 == -2) 40; 40x60 + // (axis == 3 == -1) 60 + // Furthermore, bottom[1] may have the empty shape (regardless of the value of + // "axis") -- a scalar bias. + optional int32 axis = 1 [default = 1]; + + // (num_axes is ignored unless just one bottom is given and the bias is + // a learned parameter of the layer. Otherwise, num_axes is determined by the + // number of axes by the second bottom.) + // The number of axes of the input (bottom[0]) covered by the bias + // parameter, or -1 to cover all axes of bottom[0] starting from `axis`. + // Set num_axes := 0, to add a zero-axis Blob: a scalar. + optional int32 num_axes = 2 [default = 1]; + + // (filler is ignored unless just one bottom is given and the bias is + // a learned parameter of the layer.) + // The initialization for the learned bias parameter. + // Default is the zero (0) initialization, resulting in the BiasLayer + // initially performing the identity operation. + optional FillerParameter filler = 3; +} + +message ContrastiveLossParameter { + // margin for dissimilar pair + optional float margin = 1 [default = 1.0]; + // The first implementation of this cost did not exactly match the cost of + // Hadsell et al 2006 -- using (margin - d^2) instead of (margin - d)^2. + // legacy_version = false (the default) uses (margin - d)^2 as proposed in the + // Hadsell paper. New models should probably use this version. + // legacy_version = true uses (margin - d^2). This is kept to support / + // reproduce existing models and results + optional bool legacy_version = 2 [default = false]; +} + +message ConvolutionParameter { + optional uint32 num_output = 1; // The number of outputs for the layer + optional bool bias_term = 2 [default = true]; // whether to have bias terms + + // Pad, kernel size, and stride are all given as a single value for equal + // dimensions in all spatial dimensions, or once per spatial dimension. + repeated uint32 pad = 3; // The padding size; defaults to 0 + repeated uint32 kernel_size = 4; // The kernel size + repeated uint32 stride = 6; // The stride; defaults to 1 + // Factor used to dilate the kernel, (implicitly) zero-filling the resulting + // holes. (Kernel dilation is sometimes referred to by its use in the + // algorithme à trous from Holschneider et al. 1987.) + repeated uint32 dilation = 18; // The dilation; defaults to 1 + + // For 2D convolution only, the *_h and *_w versions may also be used to + // specify both spatial dimensions. + optional uint32 pad_h = 9 [default = 0]; // The padding height (2D only) + optional uint32 pad_w = 10 [default = 0]; // The padding width (2D only) + optional uint32 kernel_h = 11; // The kernel height (2D only) + optional uint32 kernel_w = 12; // The kernel width (2D only) + optional uint32 stride_h = 13; // The stride height (2D only) + optional uint32 stride_w = 14; // The stride width (2D only) + + optional uint32 group = 5 [default = 1]; // The group size for group conv + + optional FillerParameter weight_filler = 7; // The filler for the weight + optional FillerParameter bias_filler = 8; // The filler for the bias + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 15 [default = DEFAULT]; + + // The axis to interpret as "channels" when performing convolution. + // Preceding dimensions are treated as independent inputs; + // succeeding dimensions are treated as "spatial". + // With (N, C, H, W) inputs, and axis == 1 (the default), we perform + // N independent 2D convolutions, sliding C-channel (or (C/g)-channels, for + // groups g>1) filters across the spatial axes (H, W) of the input. + // With (N, C, D, H, W) inputs, and axis == 1, we perform + // N independent 3D convolutions, sliding (C/g)-channels + // filters across the spatial axes (D, H, W) of the input. + optional int32 axis = 16 [default = 1]; + + // Whether to force use of the general ND convolution, even if a specific + // implementation for blobs of the appropriate number of spatial dimensions + // is available. (Currently, there is only a 2D-specific convolution + // implementation; for input blobs with num_axes != 2, this option is + // ignored and the ND implementation will be used.) + optional bool force_nd_im2col = 17 [default = false]; +} + +message CropParameter { + // To crop, elements of the first bottom are selected to fit the dimensions + // of the second, reference bottom. The crop is configured by + // - the crop `axis` to pick the dimensions for cropping + // - the crop `offset` to set the shift for all/each dimension + // to align the cropped bottom with the reference bottom. + // All dimensions up to but excluding `axis` are preserved, while + // the dimensions including and trailing `axis` are cropped. + // If only one `offset` is set, then all dimensions are offset by this amount. + // Otherwise, the number of offsets must equal the number of cropped axes to + // shift the crop in each dimension accordingly. + // Note: standard dimensions are N,C,H,W so the default is a spatial crop, + // and `axis` may be negative to index from the end (e.g., -1 for the last + // axis). + optional int32 axis = 1 [default = 2]; + repeated uint32 offset = 2; +} + +message DataParameter { + enum DB { + LEVELDB = 0; + LMDB = 1; + } + // Specify the data source. + optional string source = 1; + // Specify the batch size. + optional uint32 batch_size = 4; + // The rand_skip variable is for the data layer to skip a few data points + // to avoid all asynchronous sgd clients to start at the same point. The skip + // point would be set as rand_skip * rand(0,1). Note that rand_skip should not + // be larger than the number of keys in the database. + // DEPRECATED. Each solver accesses a different subset of the database. + optional uint32 rand_skip = 7 [default = 0]; + optional DB backend = 8 [default = LEVELDB]; + // DEPRECATED. See TransformationParameter. For data pre-processing, we can do + // simple scaling and subtracting the data mean, if provided. Note that the + // mean subtraction is always carried out before scaling. + optional float scale = 2 [default = 1]; + optional string mean_file = 3; + // DEPRECATED. See TransformationParameter. Specify if we would like to randomly + // crop an image. + optional uint32 crop_size = 5 [default = 0]; + // DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror + // data. + optional bool mirror = 6 [default = false]; + // Force the encoded image to have 3 color channels + optional bool force_encoded_color = 9 [default = false]; + // Prefetch queue (Number of batches to prefetch to host memory, increase if + // data access bandwidth varies). + optional uint32 prefetch = 10 [default = 4]; +} + +message NonMaximumSuppressionParameter { + // Threshold to be used in nms. + optional float nms_threshold = 1 [default = 0.3]; + // Maximum number of results to be kept. + optional int32 top_k = 2; + // Parameter for adaptive nms. + optional float eta = 3 [default = 1.0]; +} + +message SaveOutputParameter { + // Output directory. If not empty, we will save the results. + optional string output_directory = 1; + // Output name prefix. + optional string output_name_prefix = 2; + // Output format. + // VOC - PASCAL VOC output format. + // COCO - MS COCO output format. + optional string output_format = 3; + // If you want to output results, must also provide the following two files. + // Otherwise, we will ignore saving results. + // label map file. + optional string label_map_file = 4; + // A file which contains a list of names and sizes with same order + // of the input DB. The file is in the following format: + // name height width + // ... + optional string name_size_file = 5; + // Number of test images. It can be less than the lines specified in + // name_size_file. For example, when we only want to evaluate on part + // of the test images. + optional uint32 num_test_image = 6; +} + +message DropoutParameter { + optional float dropout_ratio = 1 [default = 0.5]; // dropout ratio +} + +// DummyDataLayer fills any number of arbitrarily shaped blobs with random +// (or constant) data generated by "Fillers" (see "message FillerParameter"). +message DummyDataParameter { + // This layer produces N >= 1 top blobs. DummyDataParameter must specify 1 or N + // shape fields, and 0, 1 or N data_fillers. + // + // If 0 data_fillers are specified, ConstantFiller with a value of 0 is used. + // If 1 data_filler is specified, it is applied to all top blobs. If N are + // specified, the ith is applied to the ith top blob. + repeated FillerParameter data_filler = 1; + repeated BlobShape shape = 6; + + // 4D dimensions -- deprecated. Use "shape" instead. + repeated uint32 num = 2; + repeated uint32 channels = 3; + repeated uint32 height = 4; + repeated uint32 width = 5; +} + +message EltwiseParameter { + enum EltwiseOp { + PROD = 0; + SUM = 1; + MAX = 2; + } + optional EltwiseOp operation = 1 [default = SUM]; // element-wise operation + repeated float coeff = 2; // blob-wise coefficient for SUM operation + + // Whether to use an asymptotically slower (for >2 inputs) but stabler method + // of computing the gradient for the PROD operation. (No effect for SUM op.) + optional bool stable_prod_grad = 3 [default = true]; +} + +// Message that stores parameters used by ELULayer +message ELUParameter { + // Described in: + // Clevert, D.-A., Unterthiner, T., & Hochreiter, S. (2015). Fast and Accurate + // Deep Network Learning by Exponential Linear Units (ELUs). arXiv + optional float alpha = 1 [default = 1]; +} + +// Message that stores parameters used by EmbedLayer +message EmbedParameter { + optional uint32 num_output = 1; // The number of outputs for the layer + // The input is given as integers to be interpreted as one-hot + // vector indices with dimension num_input. Hence num_input should be + // 1 greater than the maximum possible input value. + optional uint32 input_dim = 2; + + optional bool bias_term = 3 [default = true]; // Whether to use a bias term + optional FillerParameter weight_filler = 4; // The filler for the weight + optional FillerParameter bias_filler = 5; // The filler for the bias + +} + +// Message that stores parameters used by ExpLayer +message ExpParameter { + // ExpLayer computes outputs y = base ^ (shift + scale * x), for base > 0. + // Or if base is set to the default (-1), base is set to e, + // so y = exp(shift + scale * x). + optional float base = 1 [default = -1.0]; + optional float scale = 2 [default = 1.0]; + optional float shift = 3 [default = 0.0]; +} + +/// Message that stores parameters used by FlattenLayer +message FlattenParameter { + // The first axis to flatten: all preceding axes are retained in the output. + // May be negative to index from the end (e.g., -1 for the last axis). + optional int32 axis = 1 [default = 1]; + + // The last axis to flatten: all following axes are retained in the output. + // May be negative to index from the end (e.g., the default -1 for the last + // axis). + optional int32 end_axis = 2 [default = -1]; +} + +// Message that stores parameters used by HDF5DataLayer +message HDF5DataParameter { + // Specify the data source. + optional string source = 1; + // Specify the batch size. + optional uint32 batch_size = 2; + + // Specify whether to shuffle the data. + // If shuffle == true, the ordering of the HDF5 files is shuffled, + // and the ordering of data within any given HDF5 file is shuffled, + // but data between different files are not interleaved; all of a file's + // data are output (in a random order) before moving onto another file. + optional bool shuffle = 3 [default = false]; +} + +message HDF5OutputParameter { + optional string file_name = 1; +} + +message HingeLossParameter { + enum Norm { + L1 = 1; + L2 = 2; + } + // Specify the Norm to use L1 or L2 + optional Norm norm = 1 [default = L1]; +} + +message ImageDataParameter { + // Specify the data source. + optional string source = 1; + // Specify the batch size. + optional uint32 batch_size = 4 [default = 1]; + // The rand_skip variable is for the data layer to skip a few data points + // to avoid all asynchronous sgd clients to start at the same point. The skip + // point would be set as rand_skip * rand(0,1). Note that rand_skip should not + // be larger than the number of keys in the database. + optional uint32 rand_skip = 7 [default = 0]; + // Whether or not ImageLayer should shuffle the list of files at every epoch. + optional bool shuffle = 8 [default = false]; + // It will also resize images if new_height or new_width are not zero. + optional uint32 new_height = 9 [default = 0]; + optional uint32 new_width = 10 [default = 0]; + // Specify if the images are color or gray + optional bool is_color = 11 [default = true]; + // DEPRECATED. See TransformationParameter. For data pre-processing, we can do + // simple scaling and subtracting the data mean, if provided. Note that the + // mean subtraction is always carried out before scaling. + optional float scale = 2 [default = 1]; + optional string mean_file = 3; + // DEPRECATED. See TransformationParameter. Specify if we would like to randomly + // crop an image. + optional uint32 crop_size = 5 [default = 0]; + // DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror + // data. + optional bool mirror = 6 [default = false]; + optional string root_folder = 12 [default = ""]; +} + +message InfogainLossParameter { + // Specify the infogain matrix source. + optional string source = 1; +} + +message InnerProductParameter { + optional uint32 num_output = 1; // The number of outputs for the layer + optional bool bias_term = 2 [default = true]; // whether to have bias terms + optional FillerParameter weight_filler = 3; // The filler for the weight + optional FillerParameter bias_filler = 4; // The filler for the bias + + // The first axis to be lumped into a single inner product computation; + // all preceding axes are retained in the output. + // May be negative to index from the end (e.g., -1 for the last axis). + optional int32 axis = 5 [default = 1]; + // Specify whether to transpose the weight matrix or not. + // If transpose == true, any operations will be performed on the transpose + // of the weight matrix. The weight matrix itself is not going to be transposed + // but rather the transfer flag of operations will be toggled accordingly. + optional bool transpose = 6 [default = false]; +} + +message InputParameter { + // 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. + repeated BlobShape shape = 1; +} + +// Message that stores parameters used by LogLayer +message LogParameter { + // LogLayer computes outputs y = log_base(shift + scale * x), for base > 0. + // Or if base is set to the default (-1), base is set to e, + // so y = ln(shift + scale * x) = log_e(shift + scale * x) + optional float base = 1 [default = -1.0]; + optional float scale = 2 [default = 1.0]; + optional float shift = 3 [default = 0.0]; +} + +// Message that stores parameters used by LRNLayer +message LRNParameter { + optional uint32 local_size = 1 [default = 5]; + optional float alpha = 2 [default = 1.]; + optional float beta = 3 [default = 0.75]; + enum NormRegion { + ACROSS_CHANNELS = 0; + WITHIN_CHANNEL = 1; + } + optional NormRegion norm_region = 4 [default = ACROSS_CHANNELS]; + optional float k = 5 [default = 1.]; + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 6 [default = DEFAULT]; +} + +message MemoryDataParameter { + optional uint32 batch_size = 1; + optional uint32 channels = 2; + optional uint32 height = 3; + optional uint32 width = 4; +} + +message MVNParameter { + // This parameter can be set to false to normalize mean only + optional bool normalize_variance = 1 [default = true]; + + // This parameter can be set to true to perform DNN-like MVN + optional bool across_channels = 2 [default = false]; + + // Epsilon for not dividing by zero while normalizing variance + optional float eps = 3 [default = 1e-9]; +} + +message ParameterParameter { + optional BlobShape shape = 1; +} + +message PoolingParameter { + enum PoolMethod { + MAX = 0; + AVE = 1; + STOCHASTIC = 2; + } + optional PoolMethod pool = 1 [default = MAX]; // The pooling method + // Pad, kernel size, and stride are all given as a single value for equal + // dimensions in height and width or as Y, X pairs. + optional uint32 pad = 4 [default = 0]; // The padding size (equal in Y, X) + optional uint32 pad_h = 9 [default = 0]; // The padding height + optional uint32 pad_w = 10 [default = 0]; // The padding width + optional uint32 kernel_size = 2; // The kernel size (square) + optional uint32 kernel_h = 5; // The kernel height + optional uint32 kernel_w = 6; // The kernel width + optional uint32 stride = 3 [default = 1]; // The stride (equal in Y, X) + optional uint32 stride_h = 7; // The stride height + optional uint32 stride_w = 8; // The stride width + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 11 [default = DEFAULT]; + // If global_pooling then it will pool over the size of the bottom by doing + // kernel_h = bottom->height and kernel_w = bottom->width + optional bool global_pooling = 12 [default = false]; +} + +message PowerParameter { + // PowerLayer computes outputs y = (shift + scale * x) ^ power. + optional float power = 1 [default = 1.0]; + optional float scale = 2 [default = 1.0]; + optional float shift = 3 [default = 0.0]; +} + +message PythonParameter { + optional string module = 1; + optional string 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 a number, + // string, dictionary in Python dict format, JSON, etc. You may parse this + // string in `setup` method and use it in `forward` and `backward`. + optional string param_str = 3 [default = '']; + // Whether this PythonLayer is shared among worker solvers during data parallelism. + // If true, each worker solver sequentially run forward from this layer. + // This value should be set true if you are using it as a data layer. + optional bool share_in_parallel = 4 [default = false]; +} + +// Message that stores parameters used by RecurrentLayer +message RecurrentParameter { + // The dimension of the output (and usually hidden state) representation -- + // must be explicitly set to non-zero. + optional uint32 num_output = 1 [default = 0]; + + optional FillerParameter weight_filler = 2; // The filler for the weight + optional FillerParameter bias_filler = 3; // The filler for the bias + + // Whether to enable displaying debug_info in the unrolled recurrent net. + optional bool debug_info = 4 [default = false]; + + // Whether to add as additional inputs (bottoms) the initial hidden state + // blobs, and add as additional outputs (tops) the final timestep hidden state + // blobs. The number of additional bottom/top blobs required depends on the + // recurrent architecture -- e.g., 1 for RNNs, 2 for LSTMs. + optional bool expose_hidden = 5 [default = false]; +} + +// Message that stores parameters used by ReductionLayer +message ReductionParameter { + enum ReductionOp { + SUM = 1; + ASUM = 2; + SUMSQ = 3; + MEAN = 4; + } + + optional ReductionOp operation = 1 [default = SUM]; // reduction operation + + // The first axis to reduce to a scalar -- may be negative to index from the + // end (e.g., -1 for the last axis). + // (Currently, only reduction along ALL "tail" axes is supported; reduction + // of axis M through N, where N < num_axes - 1, is unsupported.) + // Suppose we have an n-axis bottom Blob with shape: + // (d0, d1, d2, ..., d(m-1), dm, d(m+1), ..., d(n-1)). + // If axis == m, the output Blob will have shape + // (d0, d1, d2, ..., d(m-1)), + // and the ReductionOp operation is performed (d0 * d1 * d2 * ... * d(m-1)) + // times, each including (dm * d(m+1) * ... * d(n-1)) individual data. + // If axis == 0 (the default), the output Blob always has the empty shape + // (count 1), performing reduction across the entire input -- + // often useful for creating new loss functions. + optional int32 axis = 2 [default = 0]; + + optional float coeff = 3 [default = 1.0]; // coefficient for output +} + +// Message that stores parameters used by ReLULayer +message ReLUParameter { + // Allow non-zero slope for negative inputs to speed up optimization + // Described in: + // Maas, A. L., Hannun, A. Y., & Ng, A. Y. (2013). Rectifier nonlinearities + // improve neural network acoustic models. In ICML Workshop on Deep Learning + // for Audio, Speech, and Language Processing. + optional float negative_slope = 1 [default = 0]; + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 2 [default = DEFAULT]; +} + +message ReshapeParameter { + // Specify the output dimensions. If some of the dimensions are set to 0, + // the corresponding dimension from the bottom layer is used (unchanged). + // Exactly one dimension may be set to -1, in which case its value is + // inferred from the count of the bottom blob and the remaining dimensions. + // For example, suppose we want to reshape a 2D blob "input" with shape 2 x 8: + // + // layer { + // type: "Reshape" bottom: "input" top: "output" + // reshape_param { ... } + // } + // + // If "input" is 2D with shape 2 x 8, then the following reshape_param + // specifications are all equivalent, producing a 3D blob "output" with shape + // 2 x 2 x 4: + // + // reshape_param { shape { dim: 2 dim: 2 dim: 4 } } + // reshape_param { shape { dim: 0 dim: 2 dim: 4 } } + // reshape_param { shape { dim: 0 dim: 2 dim: -1 } } + // reshape_param { shape { dim: 0 dim:-1 dim: 4 } } + // + optional BlobShape shape = 1; + + // axis and num_axes control the portion of the bottom blob's shape that are + // replaced by (included in) the reshape. By default (axis == 0 and + // num_axes == -1), the entire bottom blob shape is included in the reshape, + // and hence the shape field must specify the entire output shape. + // + // axis may be non-zero to retain some portion of the beginning of the input + // shape (and may be negative to index from the end; e.g., -1 to begin the + // reshape after the last axis, including nothing in the reshape, + // -2 to include only the last axis, etc.). + // + // For example, suppose "input" is a 2D blob with shape 2 x 8. + // Then the following ReshapeLayer specifications are all equivalent, + // producing a blob "output" with shape 2 x 2 x 4: + // + // reshape_param { shape { dim: 2 dim: 2 dim: 4 } } + // reshape_param { shape { dim: 2 dim: 4 } axis: 1 } + // reshape_param { shape { dim: 2 dim: 4 } axis: -3 } + // + // num_axes specifies the extent of the reshape. + // If num_axes >= 0 (and axis >= 0), the reshape will be performed only on + // input axes in the range [axis, axis+num_axes]. + // num_axes may also be -1, the default, to include all remaining axes + // (starting from axis). + // + // For example, suppose "input" is a 2D blob with shape 2 x 8. + // Then the following ReshapeLayer specifications are equivalent, + // producing a blob "output" with shape 1 x 2 x 8. + // + // reshape_param { shape { dim: 1 dim: 2 dim: 8 } } + // reshape_param { shape { dim: 1 dim: 2 } num_axes: 1 } + // reshape_param { shape { dim: 1 } num_axes: 0 } + // + // On the other hand, these would produce output blob shape 2 x 1 x 8: + // + // reshape_param { shape { dim: 2 dim: 1 dim: 8 } } + // reshape_param { shape { dim: 1 } axis: 1 num_axes: 0 } + // + optional int32 axis = 2 [default = 0]; + optional int32 num_axes = 3 [default = -1]; +} + +message ScaleParameter { + // The first axis of bottom[0] (the first input Blob) along which to apply + // bottom[1] (the second input Blob). May be negative to index from the end + // (e.g., -1 for the last axis). + // + // For example, if bottom[0] is 4D with shape 100x3x40x60, the output + // top[0] will have the same shape, and bottom[1] may have any of the + // following shapes (for the given value of axis): + // (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60 + // (axis == 1 == -3) 3; 3x40; 3x40x60 + // (axis == 2 == -2) 40; 40x60 + // (axis == 3 == -1) 60 + // Furthermore, bottom[1] may have the empty shape (regardless of the value of + // "axis") -- a scalar multiplier. + optional int32 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 determined by the + // number of axes by the second bottom.) + // The number of axes of the input (bottom[0]) covered by the scale + // parameter, or -1 to cover all axes of bottom[0] starting from `axis`. + // Set num_axes := 0, to multiply with a zero-axis Blob: a scalar. + optional int32 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. + optional FillerParameter filler = 3; + + // Whether to also learn a bias (equivalent to a ScaleLayer+BiasLayer, but + // may be more efficient). Initialized with bias_filler (defaults to 0). + optional bool bias_term = 4 [default = false]; + optional FillerParameter bias_filler = 5; +} + +message SigmoidParameter { + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 1 [default = DEFAULT]; +} + +message SliceParameter { + // The axis along which to slice -- may be negative to index from the end + // (e.g., -1 for the last axis). + // By default, SliceLayer concatenates blobs along the "channels" axis (1). + optional int32 axis = 3 [default = 1]; + repeated uint32 slice_point = 2; + + // DEPRECATED: alias for "axis" -- does not support negative indexing. + optional uint32 slice_dim = 1 [default = 1]; +} + +// Message that stores parameters used by SoftmaxLayer, SoftmaxWithLossLayer +message SoftmaxParameter { + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 1 [default = DEFAULT]; + + // The axis along which to perform the softmax -- may be negative to index + // from the end (e.g., -1 for the last axis). + // Any other axes will be evaluated as independent softmaxes. + optional int32 axis = 2 [default = 1]; +} + +message TanHParameter { + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 1 [default = DEFAULT]; +} + +// Message that stores parameters used by TileLayer +message TileParameter { + // The index of the axis to tile. + optional int32 axis = 1 [default = 1]; + + // The number of copies (tiles) of the blob to output. + optional int32 tiles = 2; +} + +// Message that stores parameters used by ThresholdLayer +message ThresholdParameter { + optional float threshold = 1 [default = 0]; // Strictly positive values +} + +message WindowDataParameter { + // Specify the data source. + optional string source = 1; + // For data pre-processing, we can do simple scaling and subtracting the + // data mean, if provided. Note that the mean subtraction is always carried + // out before scaling. + optional float scale = 2 [default = 1]; + optional string mean_file = 3; + // Specify the batch size. + optional uint32 batch_size = 4; + // Specify if we would like to randomly crop an image. + optional uint32 crop_size = 5 [default = 0]; + // Specify if we want to randomly mirror data. + optional bool mirror = 6 [default = false]; + // Foreground (object) overlap threshold + optional float fg_threshold = 7 [default = 0.5]; + // Background (non-object) overlap threshold + optional float bg_threshold = 8 [default = 0.5]; + // Fraction of batch that should be foreground objects + optional float fg_fraction = 9 [default = 0.25]; + // Amount of contextual padding to add around a window + // (used only by the window_data_layer) + optional uint32 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 + optional string crop_mode = 11 [default = "warp"]; + // cache_images: will load all images in memory for faster access + optional bool cache_images = 12 [default = false]; + // append root_folder to locate images + optional string root_folder = 13 [default = ""]; +} + +message SPPParameter { + enum PoolMethod { + MAX = 0; + AVE = 1; + STOCHASTIC = 2; + } + optional uint32 pyramid_height = 1; + optional PoolMethod pool = 2 [default = MAX]; // The pooling method + enum Engine { + DEFAULT = 0; + CAFFE = 1; + CUDNN = 2; + } + optional Engine engine = 6 [default = 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; + 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; + } + 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 LossParameter loss_param = 42; + 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 { + optional string name = 1; // the layer name + optional string type = 2; // the string to specify the layer type + + // Parameters to specify layers with inner products. + optional uint32 num_output = 3; // The number of outputs for the layer + optional bool biasterm = 4 [default = true]; // whether to have bias terms + optional FillerParameter weight_filler = 5; // The filler for the weight + optional FillerParameter bias_filler = 6; // The filler for the bias + + optional uint32 pad = 7 [default = 0]; // The padding size + optional uint32 kernelsize = 8; // The kernel size + optional uint32 group = 9 [default = 1]; // The group size for group conv + optional uint32 stride = 10 [default = 1]; // The stride + enum PoolMethod { + MAX = 0; + AVE = 1; + STOCHASTIC = 2; + } + optional PoolMethod pool = 11 [default = MAX]; // The pooling method + optional float dropout_ratio = 12 [default = 0.5]; // dropout ratio + + optional uint32 local_size = 13 [default = 5]; // for local response norm + optional float alpha = 14 [default = 1.]; // for local response norm + optional float beta = 15 [default = 0.75]; // for local response norm + optional float k = 22 [default = 1.]; + + // For data layers, specify the data source + optional string source = 16; + // For data pre-processing, we can do simple scaling and subtracting the + // data mean, if provided. Note that the mean subtraction is always carried + // out before scaling. + optional float scale = 17 [default = 1]; + optional string meanfile = 18; + // For data layers, specify the batch size. + optional uint32 batchsize = 19; + // For data layers, specify if we would like to randomly crop an image. + optional uint32 cropsize = 20 [default = 0]; + // For data layers, specify if we want to randomly mirror data. + optional bool mirror = 21 [default = false]; + + // The blobs containing the numeric parameters of the layer + repeated BlobProto blobs = 50; + // The ratio that is multiplied on the global learning rate. If you want to + // set the learning ratio for one blob, you need to set it for all blobs. + repeated float blobs_lr = 51; + // The weight decay that is multiplied on the global weight decay. + repeated float weight_decay = 52; + + // The rand_skip variable is for the data layer to skip a few data points + // to avoid all asynchronous sgd clients to start at the same point. The skip + // point would be set as rand_skip * rand(0,1). Note that rand_skip should not + // be larger than the number of keys in the database. + optional uint32 rand_skip = 53 [default = 0]; + + // Fields related to detection (det_*) + // foreground (object) overlap threshold + optional float det_fg_threshold = 54 [default = 0.5]; + // background (non-object) overlap threshold + optional float det_bg_threshold = 55 [default = 0.5]; + // Fraction of batch that should be foreground objects + optional float 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) + optional uint32 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 + optional string det_crop_mode = 59 [default = "warp"]; + + // For ReshapeLayer, one needs to specify the new dimensions. + optional int32 new_num = 60 [default = 0]; + optional int32 new_channels = 61 [default = 0]; + optional int32 new_height = 62 [default = 0]; + optional int32 new_width = 63 [default = 0]; + + // Whether or not ImageLayer should shuffle the list of files at every epoch. + // It will also resize images if new_height or new_width are not zero. + optional bool shuffle_images = 64 [default = false]; + + // For ConcatLayer, one needs to specify the dimension for concatenation, and + // the other dimensions must be the same for all the bottom blobs. + // By default it will concatenate blobs along the channels dimension. + optional uint32 concat_dim = 65 [default = 1]; + + optional HDF5OutputParameter hdf5_output_param = 1001; +} + +message PReLUParameter { + // Parametric ReLU described in K. He et al, Delving Deep into Rectifiers: + // Surpassing Human-Level Performance on ImageNet Classification, 2015. + + // Initial value of a_i. Default is a_i=0.25 for all i. + optional FillerParameter filler = 1; + // Whether or not slope parameters are shared across channels. + optional bool channel_shared = 2 [default = false]; +} + +// The normalized bounding box [0, 1] w.r.t. the input image size. +message NormalizedBBox { + optional float xmin = 1; + optional float ymin = 2; + optional float xmax = 3; + optional float ymax = 4; + optional int32 label = 5; + optional bool difficult = 6; + optional float score = 7; + optional float size = 8; +} diff --git a/modules/dnn/src/caffe/caffe_importer.cpp b/modules/dnn/src/caffe/caffe_importer.cpp new file mode 100644 index 0000000000..15aae982f5 --- /dev/null +++ b/modules/dnn/src/caffe/caffe_importer.cpp @@ -0,0 +1,382 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +using namespace cv; +using namespace cv::dnn; + +#if HAVE_PROTOBUF +#include "caffe.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include "caffe_io.hpp" + +using ::google::protobuf::RepeatedField; +using ::google::protobuf::RepeatedPtrField; +using ::google::protobuf::Message; +using ::google::protobuf::Descriptor; +using ::google::protobuf::FieldDescriptor; +using ::google::protobuf::Reflection; + +namespace +{ + +template +static cv::String toString(const T &v) +{ + std::ostringstream ss; + ss << v; + return ss.str(); +} + +class CaffeImporter : public Importer +{ + caffe::NetParameter net; + caffe::NetParameter netBinary; + +public: + + CaffeImporter(const char *pototxt, const char *caffeModel) + { + ReadNetParamsFromTextFileOrDie(pototxt, &net); + + if (caffeModel && caffeModel[0]) + ReadNetParamsFromBinaryFileOrDie(caffeModel, &netBinary); + } + + void addParam(const Message &msg, const FieldDescriptor *field, cv::dnn::LayerParams ¶ms) + { + const Reflection *refl = msg.GetReflection(); + int type = field->cpp_type(); + bool isRepeated = field->is_repeated(); + const std::string &name = field->name(); + + #define SET_UP_FILED(getter, arrayConstr, gtype) \ + if (isRepeated) { \ + const RepeatedField &v = refl->GetRepeatedField(msg, field); \ + params.set(name, DictValue::arrayConstr(v.begin(), (int)v.size())); \ + } \ + else { \ + params.set(name, refl->getter(msg, field)); \ + } + + switch (type) + { + case FieldDescriptor::CPPTYPE_INT32: + SET_UP_FILED(GetInt32, arrayInt, ::google::protobuf::int32); + break; + case FieldDescriptor::CPPTYPE_UINT32: + SET_UP_FILED(GetUInt32, arrayInt, ::google::protobuf::uint32); + break; + case FieldDescriptor::CPPTYPE_INT64: + SET_UP_FILED(GetInt32, arrayInt, ::google::protobuf::int64); + break; + case FieldDescriptor::CPPTYPE_UINT64: + SET_UP_FILED(GetUInt32, arrayInt, ::google::protobuf::uint64); + break; + case FieldDescriptor::CPPTYPE_BOOL: + SET_UP_FILED(GetBool, arrayInt, bool); + break; + case FieldDescriptor::CPPTYPE_DOUBLE: + SET_UP_FILED(GetDouble, arrayReal, double); + break; + case FieldDescriptor::CPPTYPE_FLOAT: + SET_UP_FILED(GetFloat, arrayReal, float); + break; + case FieldDescriptor::CPPTYPE_STRING: + if (isRepeated) { + const RepeatedPtrField &v = refl->GetRepeatedPtrField(msg, field); + params.set(name, DictValue::arrayString(v.begin(), (int)v.size())); + } + else { + params.set(name, refl->GetString(msg, field)); + } + break; + case FieldDescriptor::CPPTYPE_ENUM: + if (isRepeated) { + int size = refl->FieldSize(msg, field); + std::vector buf(size); + for (int i = 0; i < size; i++) + buf[i] = refl->GetRepeatedEnum(msg, field, i)->name(); + params.set(name, DictValue::arrayString(buf.begin(), size)); + } + else { + params.set(name, refl->GetEnum(msg, field)->name()); + } + break; + default: + CV_Error(Error::StsError, "Unknown type \"" + String(field->type_name()) + "\" in prototxt"); + break; + } + } + + inline static bool ends_with_param(const std::string &str) + { + static const std::string _param("_param"); + return (str.size() >= _param.size()) && str.compare(str.size() - _param.size(), _param.size(), _param) == 0; + } + + void extractLayerParams(const Message &msg, cv::dnn::LayerParams ¶ms, bool isInternal = false) + { + const Descriptor *msgDesc = msg.GetDescriptor(); + const Reflection *msgRefl = msg.GetReflection(); + + for (int fieldId = 0; fieldId < msgDesc->field_count(); fieldId++) + { + const FieldDescriptor *fd = msgDesc->field(fieldId); + + if (!isInternal && !ends_with_param(fd->name())) + continue; + + bool hasData = fd->is_required() || + (fd->is_optional() && msgRefl->HasField(msg, fd)) || + (fd->is_repeated() && msgRefl->FieldSize(msg, fd) > 0); + if (!hasData) + continue; + + if (fd->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) + { + if (fd->is_repeated()) //Extract only first item! + extractLayerParams(msgRefl->GetRepeatedMessage(msg, fd, 0), params, true); + else + extractLayerParams(msgRefl->GetMessage(msg, fd), params, true); + } + else + { + addParam(msg, fd, params); + } + } + } + + void blobShapeFromProto(const caffe::BlobProto &pbBlob, MatShape& shape) + { + shape.clear(); + if (pbBlob.has_num() || pbBlob.has_channels() || pbBlob.has_height() || pbBlob.has_width()) + { + shape.push_back(pbBlob.num()); + shape.push_back(pbBlob.channels()); + shape.push_back(pbBlob.height()); + shape.push_back(pbBlob.width()); + } + else if (pbBlob.has_shape()) + { + const caffe::BlobShape &_shape = pbBlob.shape(); + + for (int i = 0; i < _shape.dim_size(); i++) + shape.push_back((int)_shape.dim(i)); + } + else + CV_Error(Error::StsError, "Unknown shape of input blob"); + } + + void blobFromProto(const caffe::BlobProto &pbBlob, cv::Mat &dstBlob) + { + MatShape shape; + blobShapeFromProto(pbBlob, shape); + + dstBlob.create((int)shape.size(), &shape[0], CV_32F); + CV_Assert(pbBlob.data_size() == (int)dstBlob.total()); + + CV_DbgAssert(pbBlob.GetDescriptor()->FindFieldByLowercaseName("data")->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT); + float *dstData = dstBlob.ptr(); + + for (int i = 0; i < pbBlob.data_size(); i++) + dstData[i] = pbBlob.data(i); + } + + void extractBinaryLayerParms(const caffe::LayerParameter& layer, LayerParams& layerParams) + { + const std::string &name = layer.name(); + + int li; + for (li = 0; li != netBinary.layer_size(); li++) + { + if (netBinary.layer(li).name() == name) + break; + } + + if (li == netBinary.layer_size() || netBinary.layer(li).blobs_size() == 0) + return; + + const caffe::LayerParameter &binLayer = netBinary.layer(li); + layerParams.blobs.resize(binLayer.blobs_size()); + for (int bi = 0; bi < binLayer.blobs_size(); bi++) + { + blobFromProto(binLayer.blobs(bi), layerParams.blobs[bi]); + } + } + + struct BlobNote + { + BlobNote(const std::string &_name, int _layerId, int _outNum) : + name(_name.c_str()), layerId(_layerId), outNum(_outNum) {} + + const char *name; + int layerId, outNum; + }; + + std::vector addedBlobs; + std::map layerCounter; + + void populateNet(Net dstNet) + { + int layersSize = net.layer_size(); + layerCounter.clear(); + addedBlobs.clear(); + addedBlobs.reserve(layersSize + 1); + + //setup input layer names + { + std::vector netInputs(net.input_size()); + for (int inNum = 0; inNum < net.input_size(); inNum++) + { + addedBlobs.push_back(BlobNote(net.input(inNum), 0, inNum)); + netInputs[inNum] = net.input(inNum); + } + dstNet.setInputsNames(netInputs); + } + + for (int li = 0; li < layersSize; li++) + { + const caffe::LayerParameter &layer = net.layer(li); + String name = layer.name(); + String type = layer.type(); + LayerParams layerParams; + + extractLayerParams(layer, layerParams); + extractBinaryLayerParms(layer, layerParams); + + int repetitions = layerCounter[name]++; + if (repetitions) + name += String("_") + toString(repetitions); + + int id = dstNet.addLayer(name, type, layerParams); + + for (int inNum = 0; inNum < layer.bottom_size(); inNum++) + addInput(layer.bottom(inNum), id, inNum, dstNet); + + for (int outNum = 0; outNum < layer.top_size(); outNum++) + addOutput(layer, id, outNum); + } + + addedBlobs.clear(); + } + + void addOutput(const caffe::LayerParameter &layer, int layerId, int outNum) + { + const std::string &name = layer.top(outNum); + + bool haveDups = false; + for (int idx = (int)addedBlobs.size() - 1; idx >= 0; idx--) + { + if (addedBlobs[idx].name == name) + { + haveDups = true; + break; + } + } + + if (haveDups) + { + bool isInplace = layer.bottom_size() > outNum && layer.bottom(outNum) == name; + if (!isInplace) + CV_Error(Error::StsBadArg, "Duplicate blobs produced by multiple sources"); + } + + addedBlobs.push_back(BlobNote(name, layerId, outNum)); + } + + void addInput(const std::string &name, int layerId, int inNum, Net &dstNet) + { + int idx; + for (idx = (int)addedBlobs.size() - 1; idx >= 0; idx--) + { + if (addedBlobs[idx].name == name) + break; + } + + if (idx < 0) + { + CV_Error(Error::StsObjectNotFound, "Can't find output blob \"" + name + "\""); + return; + } + + dstNet.connect(addedBlobs[idx].layerId, addedBlobs[idx].outNum, layerId, inNum); + } + + ~CaffeImporter() + { + + } + +}; + +} + +Ptr cv::dnn::createCaffeImporter(const String &prototxt, const String &caffeModel) +{ + return Ptr(new CaffeImporter(prototxt.c_str(), caffeModel.c_str())); +} + +#else //HAVE_PROTOBUF + +Ptr cv::dnn::createCaffeImporter(const String&, const String&) +{ + CV_Error(cv::Error::StsNotImplemented, "libprotobuf required to import data from Caffe models"); + return Ptr(); +} + +#endif //HAVE_PROTOBUF + +Net cv::dnn::readNetFromCaffe(const String &prototxt, const String &caffeModel /*= String()*/) +{ + Ptr caffeImporter = createCaffeImporter(prototxt, caffeModel); + Net net; + if (caffeImporter) + caffeImporter->populateNet(net); + return net; +} diff --git a/modules/dnn/src/caffe/caffe_io.cpp b/modules/dnn/src/caffe/caffe_io.cpp new file mode 100644 index 0000000000..9934dacda1 --- /dev/null +++ b/modules/dnn/src/caffe/caffe_io.cpp @@ -0,0 +1,1151 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +/*M/////////////////////////////////////////////////////////////////////////////////////// +//COPYRIGHT +// +//All contributions by the University of California: +//Copyright (c) 2014, The Regents of the University of California (Regents) +//All rights reserved. +// +//All other contributions: +//Copyright (c) 2014, the respective contributors +//All rights reserved. +// +//Caffe uses a shared copyright model: each contributor holds copyright over +//their contributions to Caffe. The project versioning records all such +//contribution and copyright details. If a contributor wants to further mark +//their specific copyright on a particular contribution, they should indicate +//their copyright solely in the commit message of the change when it is +//committed. +// +//LICENSE +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions are met: +// +//1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +//2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//CONTRIBUTION AGREEMENT +// +//By contributing to the BVLC/caffe repository through pull-request, comment, +//or otherwise, the contributor releases their content to the +//license and copyright terms herein. +// +//M*/ + +#if HAVE_PROTOBUF +#include +#include +#include + +#include + +#include +#include +#include +#include + +#include "caffe.pb.h" +#include "caffe_io.hpp" +#include "glog_emulator.hpp" + +namespace cv { +namespace dnn { + +using std::string; +using std::map; +using namespace caffe; +using namespace ::google::protobuf; +using namespace ::google::protobuf::io; + +// Return true iff the net is not the current version. +bool NetNeedsUpgrade(const NetParameter& net_param); + +// Return true iff any layer contains parameters specified using +// deprecated V0LayerParameter. +bool NetNeedsV0ToV1Upgrade(const NetParameter& net_param); + +// Perform all necessary transformations to upgrade a V0NetParameter into a +// NetParameter (including upgrading padding layers and LayerParameters). +bool UpgradeV0Net(const NetParameter& v0_net_param, NetParameter* net_param); + +// Upgrade NetParameter with padding layers to pad-aware conv layers. +// For any padding layer, remove it and put its pad parameter in any layers +// taking its top blob as input. +// Error if any of these above layers are not-conv layers. +void UpgradeV0PaddingLayers(const NetParameter& param, + NetParameter* param_upgraded_pad); + +// Upgrade a single V0LayerConnection to the V1LayerParameter format. +bool UpgradeV0LayerParameter(const V1LayerParameter& v0_layer_connection, + V1LayerParameter* layer_param); + +V1LayerParameter_LayerType UpgradeV0LayerType(const string& type); + +// Return true iff any layer contains deprecated data transformation parameters. +bool NetNeedsDataUpgrade(const NetParameter& net_param); + +// Perform all necessary transformations to upgrade old transformation fields +// into a TransformationParameter. +void UpgradeNetDataTransformation(NetParameter* net_param); + +// Return true iff the Net contains any layers specified as V1LayerParameters. +bool NetNeedsV1ToV2Upgrade(const NetParameter& net_param); + +// Perform all necessary transformations to upgrade a NetParameter with +// deprecated V1LayerParameters. +bool UpgradeV1Net(const NetParameter& v1_net_param, NetParameter* net_param); + +bool UpgradeV1LayerParameter(const V1LayerParameter& v1_layer_param, + LayerParameter* layer_param); + +const char* UpgradeV1LayerType(const V1LayerParameter_LayerType type); + +bool NetNeedsBatchNormUpgrade(const NetParameter& net_param); + +void UpgradeNetBatchNorm(NetParameter* net_param); + +// Check for deprecations and upgrade the NetParameter as needed. +bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param); + + +bool NetNeedsUpgrade(const NetParameter& net_param) { + return NetNeedsV0ToV1Upgrade(net_param) || NetNeedsV1ToV2Upgrade(net_param) || + NetNeedsBatchNormUpgrade(net_param); +} + +bool NetNeedsV0ToV1Upgrade(const NetParameter& net_param) { + for (int i = 0; i < net_param.layers_size(); ++i) { + if (net_param.layers(i).has_layer()) { + return true; + } + } + return false; +} + +bool NetNeedsV1ToV2Upgrade(const NetParameter& net_param) { + return net_param.layers_size() > 0; +} + +bool UpgradeV0Net(const NetParameter& v0_net_param_padding_layers, + NetParameter* net_param) { + // First upgrade padding layers to padded conv layers. + NetParameter v0_net_param; + UpgradeV0PaddingLayers(v0_net_param_padding_layers, &v0_net_param); + // Now upgrade layer parameters. + bool is_fully_compatible = true; + net_param->Clear(); + if (v0_net_param.has_name()) { + net_param->set_name(v0_net_param.name()); + } + for (int i = 0; i < v0_net_param.layers_size(); ++i) { + is_fully_compatible &= UpgradeV0LayerParameter(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)); + } + for (int i = 0; i < v0_net_param.input_dim_size(); ++i) { + net_param->add_input_dim(v0_net_param.input_dim(i)); + } + if (v0_net_param.has_force_backward()) { + net_param->set_force_backward(v0_net_param.force_backward()); + } + return is_fully_compatible; +} + +void UpgradeV0PaddingLayers(const NetParameter& param, + NetParameter* param_upgraded_pad) { + // Copy everything other than the layers from the original param. + param_upgraded_pad->Clear(); + param_upgraded_pad->CopyFrom(param); + param_upgraded_pad->clear_layers(); + // Figure out which layer each bottom blob comes from. + map 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.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_layers()->CopyFrom(layer_connection); + } + for (int j = 0; j < layer_connection.bottom_size(); ++j) { + const string& blob_name = layer_connection.bottom(j); + if (blob_name_to_last_top_idx.find(blob_name) == + blob_name_to_last_top_idx.end()) { + LOG(FATAL) << "Unknown blob input " << blob_name << " to layer " << j; + } + const int top_idx = blob_name_to_last_top_idx[blob_name]; + if (top_idx == -1) { + continue; + } + 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 + // the padding layer input has only one input and one output. Other + // cases have undefined behavior in Caffe. + CHECK((layer_param.type() == "conv") || (layer_param.type() == "pool")) + << "Padding layer input to " + "non-convolutional / non-pooling layer type " + << layer_param.type(); + CHECK_EQ(layer_connection.bottom_size(), 1) + << "Conv Layer takes a single blob as input."; + CHECK_EQ(source_layer.bottom_size(), 1) + << "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->layers_size() - 1; + param_upgraded_pad->mutable_layers(layer_index)->mutable_layer() + ->set_pad(source_layer.layer().pad()); + param_upgraded_pad->mutable_layers(layer_index) + ->set_bottom(j, source_layer.bottom(0)); + } + } + for (int j = 0; j < layer_connection.top_size(); ++j) { + const string& blob_name = layer_connection.top(j); + blob_name_to_last_top_idx[blob_name] = i; + } + } +} + +bool UpgradeV0LayerParameter(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) { + 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()->add_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()->add_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()->add_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_k()) { + if (type == "lrn") { + layer_param->mutable_lrn_param()->set_k(v0_layer_param.k()); + } else { + LOG(ERROR) << "Unknown parameter k 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; +} + +V1LayerParameter_LayerType UpgradeV0LayerType(const string& type) { + if (type == "accuracy") { + return V1LayerParameter_LayerType_ACCURACY; + } else if (type == "bnll") { + return V1LayerParameter_LayerType_BNLL; + } else if (type == "concat") { + return V1LayerParameter_LayerType_CONCAT; + } else if (type == "conv") { + return V1LayerParameter_LayerType_CONVOLUTION; + } else if (type == "data") { + return V1LayerParameter_LayerType_DATA; + } else if (type == "dropout") { + return V1LayerParameter_LayerType_DROPOUT; + } else if (type == "euclidean_loss") { + return V1LayerParameter_LayerType_EUCLIDEAN_LOSS; + } else if (type == "flatten") { + return V1LayerParameter_LayerType_FLATTEN; + } else if (type == "hdf5_data") { + return V1LayerParameter_LayerType_HDF5_DATA; + } else if (type == "hdf5_output") { + return V1LayerParameter_LayerType_HDF5_OUTPUT; + } else if (type == "im2col") { + return V1LayerParameter_LayerType_IM2COL; + } else if (type == "images") { + return V1LayerParameter_LayerType_IMAGE_DATA; + } else if (type == "infogain_loss") { + return V1LayerParameter_LayerType_INFOGAIN_LOSS; + } else if (type == "innerproduct") { + return V1LayerParameter_LayerType_INNER_PRODUCT; + } else if (type == "lrn") { + return V1LayerParameter_LayerType_LRN; + } else if (type == "multinomial_logistic_loss") { + return V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS; + } else if (type == "pool") { + return V1LayerParameter_LayerType_POOLING; + } else if (type == "relu") { + return V1LayerParameter_LayerType_RELU; + } else if (type == "sigmoid") { + return V1LayerParameter_LayerType_SIGMOID; + } else if (type == "softmax") { + return V1LayerParameter_LayerType_SOFTMAX; + } else if (type == "softmax_loss") { + return V1LayerParameter_LayerType_SOFTMAX_LOSS; + } else if (type == "split") { + return V1LayerParameter_LayerType_SPLIT; + } else if (type == "tanh") { + return V1LayerParameter_LayerType_TANH; + } else if (type == "window_data") { + return V1LayerParameter_LayerType_WINDOW_DATA; + } else { + LOG(FATAL) << "Unknown layer name: " << type; + return V1LayerParameter_LayerType_NONE; + } +} + +bool NetNeedsDataUpgrade(const NetParameter& net_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.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.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; } + if (layer_param.has_mirror()) { return true; } + } + } + return false; +} + +#define CONVERT_LAYER_TRANSFORM_PARAM(TYPE, Name, param_name) \ + do { \ + 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_layers(i)->mutable_transform_param(); \ + if (layer_param->has_scale()) { \ + transform_param->set_scale(layer_param->scale()); \ + layer_param->clear_scale(); \ + } \ + if (layer_param->has_mean_file()) { \ + transform_param->set_mean_file(layer_param->mean_file()); \ + layer_param->clear_mean_file(); \ + } \ + if (layer_param->has_crop_size()) { \ + transform_param->set_crop_size(layer_param->crop_size()); \ + layer_param->clear_crop_size(); \ + } \ + if (layer_param->has_mirror()) { \ + transform_param->set_mirror(layer_param->mirror()); \ + layer_param->clear_mirror(); \ + } \ + } \ + } while (0) + +void UpgradeNetDataTransformation(NetParameter* net_param) { + 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); + } +} + +bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param) { + bool success = true; + if (NetNeedsV0ToV1Upgrade(*param)) { + // NetParameter was specified using the old style (V0LayerParameter); try to + // upgrade it. + LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " + << "V0LayerParameter: " << param_file; + NetParameter original_param(*param); + if (!UpgradeV0Net(original_param, param)) { + success = false; + LOG(ERROR) << "Warning: had one or more problems upgrading " + << "V0NetParameter to NetParameter (see above); continuing anyway."; + } else { + LOG(INFO) << "Successfully upgraded file specified using deprecated " + << "V0LayerParameter"; + } + LOG(ERROR) << "Note that future Caffe releases will not support " + << "V0NetParameter; use ./build/tools/upgrade_net_proto_text for " + << "prototxt and ./build/tools/upgrade_net_proto_binary for model " + << "weights upgrade this and any other net protos to the new format."; + } + // NetParameter uses old style data transformation fields; try to upgrade it. + if (NetNeedsDataUpgrade(*param)) { + LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " + << "transformation parameters: " << param_file; + UpgradeNetDataTransformation(param); + LOG(INFO) << "Successfully upgraded file specified using deprecated " + << "data transformation parameters."; + LOG(ERROR) << "Note that future Caffe releases will only support " + << "transform_param messages for transformation fields."; + } + if (NetNeedsV1ToV2Upgrade(*param)) { + LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " + << "V1LayerParameter: " << param_file; + NetParameter original_param(*param); + if (!UpgradeV1Net(original_param, param)) { + success = false; + LOG(ERROR) << "Warning: had one or more problems upgrading " + << "V1LayerParameter (see above); continuing anyway."; + } else { + LOG(INFO) << "Successfully upgraded file specified using deprecated " + << "V1LayerParameter"; + } + } + // NetParameter uses old style batch norm layers; try to upgrade it. + if (NetNeedsBatchNormUpgrade(*param)) { + LOG(INFO) << "Attempting to upgrade batch norm layers using deprecated " + << "params: " << param_file; + UpgradeNetBatchNorm(param); + LOG(INFO) << "Successfully upgraded batch norm layers using deprecated " + << "params."; + } + return success; +} + +bool UpgradeV1Net(const NetParameter& v1_net_param, NetParameter* net_param) { + bool is_fully_compatible = true; + if (v1_net_param.layer_size() > 0) { + LOG(ERROR) << "Input NetParameter to be upgraded already specifies 'layer' " + << "fields; these will be ignored for the upgrade."; + is_fully_compatible = false; + } + net_param->CopyFrom(v1_net_param); + net_param->clear_layers(); + net_param->clear_layer(); + for (int i = 0; i < v1_net_param.layers_size(); ++i) { + if (!UpgradeV1LayerParameter(v1_net_param.layers(i), + net_param->add_layer())) { + LOG(ERROR) << "Upgrade of input layer " << i << " failed."; + is_fully_compatible = false; + } + } + return is_fully_compatible; +} + +bool NetNeedsBatchNormUpgrade(const NetParameter& net_param) { + for (int i = 0; i < net_param.layer_size(); ++i) { + // Check if BatchNorm layers declare three parameters, as required by + // the previous BatchNorm layer definition. + if (net_param.layer(i).type() == "BatchNorm" + && net_param.layer(i).param_size() == 3) { + return true; + } + } + return false; +} + +void UpgradeNetBatchNorm(NetParameter* net_param) { + for (int i = 0; i < net_param->layer_size(); ++i) { + // Check if BatchNorm layers declare three parameters, as required by + // the previous BatchNorm layer definition. + if (net_param->layer(i).type() == "BatchNorm" + && net_param->layer(i).param_size() == 3) { + net_param->mutable_layer(i)->clear_param(); + } + } +} + +bool UpgradeV1LayerParameter(const V1LayerParameter& v1_layer_param, + LayerParameter* layer_param) { + layer_param->Clear(); + bool is_fully_compatible = true; + for (int i = 0; i < v1_layer_param.bottom_size(); ++i) { + layer_param->add_bottom(v1_layer_param.bottom(i)); + } + for (int i = 0; i < v1_layer_param.top_size(); ++i) { + layer_param->add_top(v1_layer_param.top(i)); + } + if (v1_layer_param.has_name()) { + layer_param->set_name(v1_layer_param.name()); + } + for (int i = 0; i < v1_layer_param.include_size(); ++i) { + layer_param->add_include()->CopyFrom(v1_layer_param.include(i)); + } + for (int i = 0; i < v1_layer_param.exclude_size(); ++i) { + layer_param->add_exclude()->CopyFrom(v1_layer_param.exclude(i)); + } + if (v1_layer_param.has_type()) { + layer_param->set_type(UpgradeV1LayerType(v1_layer_param.type())); + } + for (int i = 0; i < v1_layer_param.blobs_size(); ++i) { + layer_param->add_blobs()->CopyFrom(v1_layer_param.blobs(i)); + } + for (int i = 0; i < v1_layer_param.param_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + layer_param->mutable_param(i)->set_name(v1_layer_param.param(i)); + } + ParamSpec_DimCheckMode mode; + for (int i = 0; i < v1_layer_param.blob_share_mode_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + switch (v1_layer_param.blob_share_mode(i)) { + case V1LayerParameter_DimCheckMode_STRICT: + mode = ParamSpec_DimCheckMode_STRICT; + break; + case V1LayerParameter_DimCheckMode_PERMISSIVE: + mode = ParamSpec_DimCheckMode_PERMISSIVE; + break; + default: + LOG(FATAL) << "Unknown blob_share_mode: " + << v1_layer_param.blob_share_mode(i); + break; + } + layer_param->mutable_param(i)->set_share_mode(mode); + } + for (int i = 0; i < v1_layer_param.blobs_lr_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + layer_param->mutable_param(i)->set_lr_mult(v1_layer_param.blobs_lr(i)); + } + for (int i = 0; i < v1_layer_param.weight_decay_size(); ++i) { + while (layer_param->param_size() <= i) { layer_param->add_param(); } + layer_param->mutable_param(i)->set_decay_mult( + v1_layer_param.weight_decay(i)); + } + for (int i = 0; i < v1_layer_param.loss_weight_size(); ++i) { + layer_param->add_loss_weight(v1_layer_param.loss_weight(i)); + } + if (v1_layer_param.has_accuracy_param()) { + layer_param->mutable_accuracy_param()->CopyFrom( + v1_layer_param.accuracy_param()); + } + if (v1_layer_param.has_argmax_param()) { + layer_param->mutable_argmax_param()->CopyFrom( + v1_layer_param.argmax_param()); + } + if (v1_layer_param.has_concat_param()) { + layer_param->mutable_concat_param()->CopyFrom( + v1_layer_param.concat_param()); + } + if (v1_layer_param.has_contrastive_loss_param()) { + layer_param->mutable_contrastive_loss_param()->CopyFrom( + v1_layer_param.contrastive_loss_param()); + } + if (v1_layer_param.has_convolution_param()) { + layer_param->mutable_convolution_param()->CopyFrom( + v1_layer_param.convolution_param()); + } + if (v1_layer_param.has_data_param()) { + layer_param->mutable_data_param()->CopyFrom( + v1_layer_param.data_param()); + } + if (v1_layer_param.has_dropout_param()) { + layer_param->mutable_dropout_param()->CopyFrom( + v1_layer_param.dropout_param()); + } + if (v1_layer_param.has_dummy_data_param()) { + layer_param->mutable_dummy_data_param()->CopyFrom( + v1_layer_param.dummy_data_param()); + } + if (v1_layer_param.has_eltwise_param()) { + layer_param->mutable_eltwise_param()->CopyFrom( + v1_layer_param.eltwise_param()); + } + if (v1_layer_param.has_exp_param()) { + layer_param->mutable_exp_param()->CopyFrom( + v1_layer_param.exp_param()); + } + if (v1_layer_param.has_hdf5_data_param()) { + layer_param->mutable_hdf5_data_param()->CopyFrom( + v1_layer_param.hdf5_data_param()); + } + if (v1_layer_param.has_hdf5_output_param()) { + layer_param->mutable_hdf5_output_param()->CopyFrom( + v1_layer_param.hdf5_output_param()); + } + if (v1_layer_param.has_hinge_loss_param()) { + layer_param->mutable_hinge_loss_param()->CopyFrom( + v1_layer_param.hinge_loss_param()); + } + if (v1_layer_param.has_image_data_param()) { + layer_param->mutable_image_data_param()->CopyFrom( + v1_layer_param.image_data_param()); + } + if (v1_layer_param.has_infogain_loss_param()) { + layer_param->mutable_infogain_loss_param()->CopyFrom( + v1_layer_param.infogain_loss_param()); + } + if (v1_layer_param.has_inner_product_param()) { + layer_param->mutable_inner_product_param()->CopyFrom( + v1_layer_param.inner_product_param()); + } + if (v1_layer_param.has_lrn_param()) { + layer_param->mutable_lrn_param()->CopyFrom( + v1_layer_param.lrn_param()); + } + if (v1_layer_param.has_memory_data_param()) { + layer_param->mutable_memory_data_param()->CopyFrom( + v1_layer_param.memory_data_param()); + } + if (v1_layer_param.has_mvn_param()) { + layer_param->mutable_mvn_param()->CopyFrom( + v1_layer_param.mvn_param()); + } + if (v1_layer_param.has_pooling_param()) { + layer_param->mutable_pooling_param()->CopyFrom( + v1_layer_param.pooling_param()); + } + if (v1_layer_param.has_power_param()) { + layer_param->mutable_power_param()->CopyFrom( + v1_layer_param.power_param()); + } + if (v1_layer_param.has_relu_param()) { + layer_param->mutable_relu_param()->CopyFrom( + v1_layer_param.relu_param()); + } + if (v1_layer_param.has_sigmoid_param()) { + layer_param->mutable_sigmoid_param()->CopyFrom( + v1_layer_param.sigmoid_param()); + } + if (v1_layer_param.has_softmax_param()) { + layer_param->mutable_softmax_param()->CopyFrom( + v1_layer_param.softmax_param()); + } + if (v1_layer_param.has_slice_param()) { + layer_param->mutable_slice_param()->CopyFrom( + v1_layer_param.slice_param()); + } + if (v1_layer_param.has_tanh_param()) { + layer_param->mutable_tanh_param()->CopyFrom( + v1_layer_param.tanh_param()); + } + if (v1_layer_param.has_threshold_param()) { + layer_param->mutable_threshold_param()->CopyFrom( + v1_layer_param.threshold_param()); + } + if (v1_layer_param.has_window_data_param()) { + layer_param->mutable_window_data_param()->CopyFrom( + v1_layer_param.window_data_param()); + } + if (v1_layer_param.has_transform_param()) { + layer_param->mutable_transform_param()->CopyFrom( + v1_layer_param.transform_param()); + } + if (v1_layer_param.has_loss_param()) { + layer_param->mutable_loss_param()->CopyFrom( + v1_layer_param.loss_param()); + } + if (v1_layer_param.has_layer()) { + LOG(ERROR) << "Input NetParameter has V0 layer -- ignoring."; + is_fully_compatible = false; + } + return is_fully_compatible; +} + +const char* UpgradeV1LayerType(const V1LayerParameter_LayerType type) { + switch (type) { + case V1LayerParameter_LayerType_NONE: + return ""; + case V1LayerParameter_LayerType_ABSVAL: + return "AbsVal"; + case V1LayerParameter_LayerType_ACCURACY: + return "Accuracy"; + case V1LayerParameter_LayerType_ARGMAX: + return "ArgMax"; + case V1LayerParameter_LayerType_BNLL: + return "BNLL"; + case V1LayerParameter_LayerType_CONCAT: + return "Concat"; + case V1LayerParameter_LayerType_CONTRASTIVE_LOSS: + return "ContrastiveLoss"; + case V1LayerParameter_LayerType_CONVOLUTION: + return "Convolution"; + case V1LayerParameter_LayerType_DECONVOLUTION: + return "Deconvolution"; + case V1LayerParameter_LayerType_DATA: + return "Data"; + case V1LayerParameter_LayerType_DROPOUT: + return "Dropout"; + case V1LayerParameter_LayerType_DUMMY_DATA: + return "DummyData"; + case V1LayerParameter_LayerType_EUCLIDEAN_LOSS: + return "EuclideanLoss"; + case V1LayerParameter_LayerType_ELTWISE: + return "Eltwise"; + case V1LayerParameter_LayerType_EXP: + return "Exp"; + case V1LayerParameter_LayerType_FLATTEN: + return "Flatten"; + case V1LayerParameter_LayerType_HDF5_DATA: + return "HDF5Data"; + case V1LayerParameter_LayerType_HDF5_OUTPUT: + return "HDF5Output"; + case V1LayerParameter_LayerType_HINGE_LOSS: + return "HingeLoss"; + case V1LayerParameter_LayerType_IM2COL: + return "Im2col"; + case V1LayerParameter_LayerType_IMAGE_DATA: + return "ImageData"; + case V1LayerParameter_LayerType_INFOGAIN_LOSS: + return "InfogainLoss"; + case V1LayerParameter_LayerType_INNER_PRODUCT: + return "InnerProduct"; + case V1LayerParameter_LayerType_LRN: + return "LRN"; + case V1LayerParameter_LayerType_MEMORY_DATA: + return "MemoryData"; + case V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS: + return "MultinomialLogisticLoss"; + case V1LayerParameter_LayerType_MVN: + return "MVN"; + case V1LayerParameter_LayerType_POOLING: + return "Pooling"; + case V1LayerParameter_LayerType_POWER: + return "Power"; + case V1LayerParameter_LayerType_RELU: + return "ReLU"; + case V1LayerParameter_LayerType_SIGMOID: + return "Sigmoid"; + case V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS: + return "SigmoidCrossEntropyLoss"; + case V1LayerParameter_LayerType_SILENCE: + return "Silence"; + case V1LayerParameter_LayerType_SOFTMAX: + return "Softmax"; + case V1LayerParameter_LayerType_SOFTMAX_LOSS: + return "SoftmaxWithLoss"; + case V1LayerParameter_LayerType_SPLIT: + return "Split"; + case V1LayerParameter_LayerType_SLICE: + return "Slice"; + case V1LayerParameter_LayerType_TANH: + return "TanH"; + case V1LayerParameter_LayerType_WINDOW_DATA: + return "WindowData"; + case V1LayerParameter_LayerType_THRESHOLD: + return "Threshold"; + default: + LOG(FATAL) << "Unknown V1LayerParameter layer type: " << type; + return ""; + } +} + +const int kProtoReadBytesLimit = INT_MAX; // Max size of 2 GB minus 1 byte. + +bool ReadProtoFromTextFile(const char* filename, Message* proto) { + std::ifstream fs(filename, std::ifstream::in); + CHECK(fs.is_open()) << "Can't open \"" << filename << "\""; + IstreamInputStream input(&fs); + bool success = google::protobuf::TextFormat::Parse(&input, proto); + fs.close(); + return success; +} + +bool ReadProtoFromBinaryFile(const char* filename, Message* proto) { + std::ifstream fs(filename, std::ifstream::in | std::ifstream::binary); + CHECK(fs.is_open()) << "Can't open \"" << filename << "\""; + ZeroCopyInputStream* raw_input = new IstreamInputStream(&fs); + CodedInputStream* coded_input = new CodedInputStream(raw_input); + coded_input->SetTotalBytesLimit(kProtoReadBytesLimit, 536870912); + + bool success = proto->ParseFromCodedStream(coded_input); + + delete coded_input; + delete raw_input; + fs.close(); + return success; +} + +void ReadNetParamsFromTextFileOrDie(const char* param_file, + NetParameter* param) { + CHECK(ReadProtoFromTextFile(param_file, param)) + << "Failed to parse NetParameter file: " << param_file; + UpgradeNetAsNeeded(param_file, param); +} + +void ReadNetParamsFromBinaryFileOrDie(const char* param_file, + NetParameter* param) { + CHECK(ReadProtoFromBinaryFile(param_file, param)) + << "Failed to parse NetParameter file: " << param_file; + UpgradeNetAsNeeded(param_file, param); +} + +} +} +#endif diff --git a/modules/dnn/src/caffe/caffe_io.hpp b/modules/dnn/src/caffe/caffe_io.hpp new file mode 100644 index 0000000000..fa16612890 --- /dev/null +++ b/modules/dnn/src/caffe/caffe_io.hpp @@ -0,0 +1,108 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +/*M/////////////////////////////////////////////////////////////////////////////////////// +//COPYRIGHT +// +//All contributions by the University of California: +//Copyright (c) 2014, The Regents of the University of California (Regents) +//All rights reserved. +// +//All other contributions: +//Copyright (c) 2014, the respective contributors +//All rights reserved. +// +//Caffe uses a shared copyright model: each contributor holds copyright over +//their contributions to Caffe. The project versioning records all such +//contribution and copyright details. If a contributor wants to further mark +//their specific copyright on a particular contribution, they should indicate +//their copyright solely in the commit message of the change when it is +//committed. +// +//LICENSE +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions are met: +// +//1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +//2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//CONTRIBUTION AGREEMENT +// +//By contributing to the BVLC/caffe repository through pull-request, comment, +//or otherwise, the contributor releases their content to the +//license and copyright terms herein. +// +//M*/ + +#ifndef __OPENCV_DNN_CAFFE_IO_HPP__ +#define __OPENCV_DNN_CAFFE_IO_HPP__ +#if HAVE_PROTOBUF + +#include "caffe.pb.h" + +namespace cv { +namespace dnn { + +// Read parameters from a file into a NetParameter proto message. +void ReadNetParamsFromTextFileOrDie(const char* param_file, + caffe::NetParameter* param); +void ReadNetParamsFromBinaryFileOrDie(const char* param_file, + caffe::NetParameter* param); + +} +} +#endif +#endif diff --git a/modules/dnn/src/caffe/glog_emulator.hpp b/modules/dnn/src/caffe/glog_emulator.hpp new file mode 100644 index 0000000000..5f674e4150 --- /dev/null +++ b/modules/dnn/src/caffe/glog_emulator.hpp @@ -0,0 +1,104 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_CAFFE_GLOG_EMULATOR_HPP__ +#define __OPENCV_DNN_CAFFE_GLOG_EMULATOR_HPP__ +#include +#include +#include +#include + +#define CHECK(cond) for(cv::dnn::GLogWrapper _logger(__FILE__, CV_Func, __LINE__, "CHECK", #cond, cond); _logger.exit(); _logger.check()) _logger.stream() +#define CHECK_EQ(a, b) for(cv::dnn::GLogWrapper _logger(__FILE__, CV_Func, __LINE__, "CHECK", #a"="#b, ((a) == (b))); _logger.exit(); _logger.check()) _logger.stream() +#define LOG(TYPE) for(cv::dnn::GLogWrapper _logger(__FILE__, CV_Func, __LINE__, #TYPE); _logger.exit(); _logger.check()) _logger.stream() + +namespace cv +{ +namespace dnn +{ + +class GLogWrapper +{ + const char *file, *func, *type, *cond_str; + int line; + bool cond_staus, exit_loop; + std::stringstream sstream; + +public: + + GLogWrapper(const char *_file, const char *_func, int _line, + const char *_type, + const char *_cond_str = NULL, bool _cond_status = true + ) : + file(_file), func(_func), type(_type), cond_str(_cond_str), + line(_line), cond_staus(_cond_status), exit_loop(true) {} + + std::iostream &stream() + { + return sstream; + } + + bool exit() + { + return exit_loop; + } + + void check() + { + exit_loop = false; + + if (cond_str && !cond_staus) + { + cv::error(cv::Error::StsError, "FAILED: " + String(cond_str) + ". " + sstream.str(), func, file, line); + } + else if (!cond_str && strcmp(type, "CHECK")) + { + if (!std::strcmp(type, "INFO")) + std::cout << sstream.str() << std::endl; + else + std::cerr << sstream.str() << std::endl; + } + } +}; + +} +} +#endif diff --git a/modules/dnn/src/dnn.cpp b/modules/dnn/src/dnn.cpp new file mode 100644 index 0000000000..4e54808177 --- /dev/null +++ b/modules/dnn/src/dnn.cpp @@ -0,0 +1,2001 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "precomp.hpp" +#include "op_halide.hpp" +#include "halide_scheduler.hpp" +#include +#include +#include +#include +#include +#include +#include + +using namespace cv; +using namespace cv::dnn; + +using std::vector; +using std::map; +using std::make_pair; +using std::set; + +namespace +{ + typedef std::vector ShapesVec; + + struct LayerShapes + { + ShapesVec in, out, internal; + // No guarantees that layer which support in-place computations + // will be computed in-place (input.data_ptr == output.data_ptr). + // If layer said that it could work in-place and layers after it + // no longer use input blob, we'll set output = input. + bool supportInPlace; + LayerShapes() {supportInPlace = false;} + }; +} + +namespace cv +{ +namespace dnn +{ + +template +static String toString(const T &v) +{ + std::ostringstream ss; + ss << v; + return ss.str(); +} + +Mat blobFromImage(const Mat& image, double scalefactor, const Size& size, + const Scalar& mean, bool swapRB) +{ + std::vector images(1, image); + return blobFromImages(images, scalefactor, size, mean, swapRB); +} + +Mat blobFromImages(const std::vector& images_, double scalefactor, Size size, + const Scalar& mean_, bool swapRB) +{ + std::vector images = images_; + for (int i = 0; i < images.size(); i++) + { + Size imgSize = images[i].size(); + if (size == Size()) + size = imgSize; + if (size != imgSize) + { + float resizeFactor = std::max(size.width / (float)imgSize.width, + size.height / (float)imgSize.height); + resize(images[i], images[i], Size(), resizeFactor, resizeFactor); + Rect crop(Point(0.5 * (images[i].cols - size.width), + 0.5 * (images[i].rows - size.height)), + size); + images[i] = images[i](crop); + } + if(images[i].depth() == CV_8U) + images[i].convertTo(images[i], CV_32F); + Scalar mean = mean_; + if (swapRB) + std::swap(mean[0], mean[2]); + + images[i] -= mean; + images[i] *= scalefactor; + } + + size_t i, nimages = images.size(); + if(nimages == 0) + return Mat(); + Mat image0 = images[0]; + int nch = image0.channels(); + CV_Assert(image0.dims == 2); + Mat blob, image; + if (nch == 3 || nch == 4) + { + int sz[] = { (int)nimages, 3, image0.rows, image0.cols }; + blob = Mat(4, sz, CV_32F); + Mat ch[4]; + + for( i = 0; i < nimages; i++ ) + { + image = images[i]; + CV_Assert(image.depth() == CV_32F); + nch = image.channels(); + CV_Assert(image.dims == 2 && (nch == 3 || nch == 4)); + CV_Assert(image.size() == image0.size()); + + for( int j = 0; j < 3; j++ ) + ch[j] = Mat(image.rows, image.cols, CV_32F, blob.ptr((int)i, j)); + if(swapRB) + std::swap(ch[0], ch[2]); + split(image, ch); + } + } + else + { + CV_Assert(nch == 1); + int sz[] = { (int)nimages, 1, image0.rows, image0.cols }; + blob = Mat(4, sz, CV_32F); + + for( i = 0; i < nimages; i++ ) + { + Mat image = images[i]; + CV_Assert(image.depth() == CV_32F); + nch = image.channels(); + CV_Assert(image.dims == 2 && (nch == 1)); + CV_Assert(image.size() == image0.size()); + + image.copyTo(Mat(image.rows, image.cols, CV_32F, blob.ptr((int)i, 0))); + } + } + return blob; +} + +struct LayerPin +{ + int lid; + int oid; + + LayerPin(int layerId = -1, int outputId = -1) + : lid(layerId), oid(outputId) {} + + bool valid() const + { + return (lid >= 0 && oid >= 0); + } + + bool equal(const LayerPin &r) const + { + return (lid == r.lid && oid == r.oid); + } + + bool operator<(const LayerPin &r) const + { + return lid < r.lid || lid == r.lid && oid < r.oid; + } + + bool operator ==(const LayerPin &r) const + { + return lid == r.lid && oid == r.oid; + } +}; + +// Objects of this class manages wrappers. For every CPU memory pointer and shape +// one and only wrapper. Now it support wrapping for single backend and target. +class BackendWrapManager +{ +public: + Ptr wrap(const Mat& m, int backendId, int targetId) + { + CV_Assert(backendId != DNN_BACKEND_DEFAULT); + + std::map >::iterator hostsIt; + // Check that the same CPU memory was previously wrapped. + hostsIt = hostWrappers.find(m.data); + if (hostsIt == hostWrappers.end()) + { + // If not wrapped before. + return (hostWrappers[m.data] = wrapHost(m, backendId, targetId)); + } + else + { + // Find if wrapper of this host and shape was created before. + std::map, Ptr >::iterator it; + std::pair key(m.data, m.size); + it = extraWrappers.find(key); + if (it == extraWrappers.end()) + { + MatShape shape(m.dims); + for (int i = 0; i < m.dims; ++i) + shape[i] = m.size.p[i]; + return (extraWrappers[key] = wrapUser(hostsIt->second, shape)); + } + else + return it->second; + } + } + + std::vector > wrap(const std::vector& mats, + int backendId, int targetId) + { + const int num = mats.size(); + std::vector > dst(num); + for (int i = 0; i < num; ++i) + { + dst[i] = wrap(*mats[i], backendId, targetId); + } + return dst; + } + + std::vector > wrap(const std::vector& mats, + int backendId, int targetId) + { + const int num = mats.size(); + std::vector > dst(num); + for (int i = 0; i < num; ++i) + { + dst[i] = wrap(mats[i], backendId, targetId); + } + return dst; + } + + void reset() + { + hostWrappers.clear(); + extraWrappers.clear(); + } + +private: + // Backend-specific wrapping function. + Ptr wrapHost(const Mat& m, int backendId, int targetId) + { + if (backendId == DNN_BACKEND_DEFAULT) + { + return Ptr(); + } + else if (backendId == DNN_BACKEND_HALIDE) + { + CV_Assert(haveHalide()); +#ifdef HAVE_HALIDE + return Ptr(new HalideBackendWrapper(targetId, m)); +#endif // HAVE_HALIDE + } + else + { + CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); + } + return Ptr(); + } + + // Backend-specific wrapping function. + Ptr wrapUser(const Ptr& host, const MatShape& shape) + { + int backendId = host->backendId; + if (backendId == DNN_BACKEND_DEFAULT) + { + return Ptr(); + } + else if (backendId == DNN_BACKEND_HALIDE) + { + CV_Assert(haveHalide()); +#ifdef HAVE_HALIDE + return Ptr(new HalideBackendWrapper(host, shape)); +#endif // HAVE_HALIDE + } + else + { + CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); + } + return Ptr(); + } + + // Wrappers that initialized for memory hosts (first wrapping of CPU data). + std::map > hostWrappers; + // The rest of wrappers. They initialized for non-host cv::Mat. + std::map, Ptr > extraWrappers; +}; + +struct LayerData +{ + LayerData() {} + LayerData(int _id, const String &_name, const String &_type, LayerParams &_params) + : id(_id), name(_name), type(_type), params(_params) + { + //add logging info + params.name = name; + params.type = type; + } + + int id; + String name; + String type; + LayerParams params; + + std::vector inputBlobsId; + std::set inputLayersId; + std::set requiredOutputs; + std::vector consumers; + + Ptr layerInstance; + std::vector outputBlobs; + std::vector inputBlobs; + std::vector internals; + // Computation nodes of implemented backends (except DEFAULT). + std::map > backendNodes; + // Flag for skip layer computation for specific backend. + std::map skipFlags; + + int flag; + + Ptr getLayerInstance() + { + if (layerInstance) + return layerInstance; + + layerInstance = LayerFactory::createLayerInstance(type, params); + if (!layerInstance) + { + CV_Error(Error::StsError, "Can't create layer \"" + name + "\" of type \"" + type + "\""); + } + + return layerInstance; + } +}; + +//fake layer containing network input blobs +struct DataLayer : public Layer +{ + void finalize(const std::vector&, std::vector&) {} + void forward(std::vector&, std::vector&, std::vector &) {} + + int outputNameToIndex(String tgtName) + { + int idx = (int)(std::find(outNames.begin(), outNames.end(), tgtName) - outNames.begin()); + return (idx < (int)outNames.size()) ? idx : -1; + } + + void setNames(const std::vector &names) + { + outNames.assign(names.begin(), names.end()); + } + +private: + std::vector outNames; +}; + +struct BlobManager +{ +public: + // Increase references counter to layer output. + void addReference(const LayerPin& lp) + { + std::map::iterator it = refCounter.find(lp); + if (it == refCounter.end()) + refCounter[lp] = 1; + else + it->second += 1; + } + + void addReferences(const std::vector& pins) + { + for (int i = 0; i < pins.size(); i++) + { + addReference(pins[i]); + } + } + + // Returns number of references to allocated memory that used in specific + // layer blob. + int numReferences(const LayerPin& lp) + { + std::map::iterator mapIt = reuseMap.find(lp); + CV_Assert(mapIt != reuseMap.end()); + LayerPin memHost = mapIt->second; + + std::map::iterator refIt = refCounter.find(memHost); + CV_Assert(refIt != refCounter.end()); + return refIt->second; + } + + // Reuse data allocated in inside the blob. + void reuse(const LayerPin& host, const LayerPin& user) + { + CV_Assert(reuseMap.find(user) == reuseMap.end()); + CV_Assert(reuseMap.find(host) != reuseMap.end()); + LayerPin memHost = reuseMap[host]; + reuseMap[user] = memHost; + if (refCounter.find(memHost) != refCounter.end()) + { + std::map::iterator userRefIt = refCounter.find(user); + if (userRefIt != refCounter.end()) + { + refCounter[memHost] += userRefIt->second; + refCounter.erase(userRefIt); + } + else + refCounter[memHost] += 1; + } + } + + // Decrease references counter to allocated memory inside specific blob. + void releaseReference(const LayerPin& lp) + { + std::map::iterator mapIt = reuseMap.find(lp); + CV_Assert(mapIt != reuseMap.end()); + + std::map::iterator refIt = refCounter.find(mapIt->second); + CV_Assert(refIt != refCounter.end()); + CV_Assert(refIt->second > 0); + refIt->second -= 1; + } + + void releaseReferences(const std::vector& pins) + { + for (int i = 0; i < pins.size(); i++) + { + releaseReference(pins[i]); + } + } + + void reuseOrCreate(const MatShape& shape, const LayerPin& lp, Mat& dst) + { + std::map::iterator hostIt; + std::map::iterator refIt; + + const int targetTotal = total(shape); + Mat bestBlob; + int bestBlobTotal = INT_MAX; + LayerPin bestBlobPin; + for (hostIt = memHosts.begin(); hostIt != memHosts.end(); ++hostIt) + { + refIt = refCounter.find(hostIt->first); + // Use only blobs that had references before because if not, + // it might be used as output. + if (refIt != refCounter.end() && refIt->second == 0) + { + Mat& unusedBlob = hostIt->second; + if (unusedBlob.total() >= targetTotal && + unusedBlob.total() < bestBlobTotal) + { + bestBlobPin = hostIt->first; + bestBlob = unusedBlob; + bestBlobTotal = unusedBlob.total(); + } + } + } + if (!bestBlob.empty()) + { + reuse(bestBlobPin, lp); + dst = Mat(shape, CV_32F, bestBlob.data); + } + else + { + // if dst already has been allocated with total(shape) elements, + // it won't be recrreated and pointer of dst.data remains the same. + dst.create(shape, CV_32F); + addHost(lp, dst); + } + } + + void allocateBlobsForLayer(LayerData &ld, const LayerShapes& layerShapes, + std::vector& pinsForInternalBlobs) + { + pinsForInternalBlobs.clear(); + + std::vector& outputBlobs = ld.outputBlobs, + &internalBlobs = ld.internals; + + const ShapesVec& outShapes = layerShapes.out, + internalShapes = layerShapes.internal; + + outputBlobs.resize(std::max((size_t)1, outShapes.size())); //layer produce at least one output blob + internalBlobs.resize(internalShapes.size()); + + CV_Assert(ld.requiredOutputs.size() <= outShapes.size()); + + // Check that layer could work in-place. + bool inPlace = false; + if (layerShapes.supportInPlace) + { + if (ld.inputBlobs.size() == 1) + { + // Get number of references to the input memory. + int numRef = numReferences(ld.inputBlobsId[0]); + // If current layer is one and only customer of this blob. + inPlace = numRef == 1; + } + } + + ShapesVec shapes(outShapes); + shapes.insert(shapes.end(), internalShapes.begin(), internalShapes.end()); + std::vector blobs; + for(int i = 0; i < outputBlobs.size(); i++) + { + blobs.push_back(&outputBlobs[i]); + } + + for(int i = 0; i < internalBlobs.size(); i++) + { + blobs.push_back(&internalBlobs[i]); + if (total(internalShapes[i])) + { + pinsForInternalBlobs.push_back(LayerPin(ld.id, ld.outputBlobs.size() + i)); + } + } + + addReferences(pinsForInternalBlobs); + + std::map > idxSizes; + for(int i = 0; i < shapes.size(); i++) + { + idxSizes[total(shapes[i])].push_back(i); + } + + std::map >::reverse_iterator it; + for(it = idxSizes.rbegin(); it != idxSizes.rend(); it++) + { + for(int j = 0; j < it->second.size(); j++) + { + int index = it->second[j]; + if (total(shapes[index])) + { + LayerPin blobPin(ld.id, index); + if (index < outShapes.size() && inPlace) + { + CV_Assert(ld.inputBlobs[0]->total() == total(shapes[index])); + ld.outputBlobs[index] = ld.inputBlobs[0]->reshape(1, shapes[index]); + reuse(ld.inputBlobsId[0], blobPin); + } + else + { + reuseOrCreate(shapes[index], blobPin, *blobs[index]); + } + } + } + } + } + + // Clear internal state. Calls before an every reallocation. + void reset() + { + refCounter.clear(); + reuseMap.clear(); + memHosts.clear(); + } + +private: + // Register allocated memory. + void addHost(const LayerPin& lp, const Mat& mat) + { + CV_Assert(memHosts.find(lp) == memHosts.end()); + reuseMap[lp] = lp; + memHosts[lp] = mat; + } + + std::map refCounter; + // Maps pin to origin blob (for whom memory was allocated firstly). + // For origin blobs key == value. + std::map reuseMap; + std::map memHosts; +}; + +struct Net::Impl +{ + typedef std::map LayersShapesMap; + typedef std::map MapIdToLayerData; + + Impl() + { + //allocate fake net input layer + netInputLayer = Ptr(new DataLayer()); + LayerData &inpl = layers.insert( make_pair(0, LayerData()) ).first->second; + inpl.id = 0; + inpl.name = "_input"; + inpl.type = "__NetInputLayer__"; + inpl.layerInstance = netInputLayer; + layerNameToId.insert(std::make_pair(inpl.name, inpl.id)); + + lastLayerId = 1; + netWasAllocated = false; + preferableBackend = DNN_BACKEND_DEFAULT; + preferableTarget = DNN_TARGET_CPU; + } + + Ptr netInputLayer; + std::vector netOutputs; + std::vector blobsToKeep; + MapIdToLayerData layers; + std::map layerNameToId; + BlobManager blobManager; + int preferableBackend; + int preferableTarget; + String halideConfigFile; + // Backend-specific wrapping manager. + BackendWrapManager backendWrapper; + + int lastLayerId; + + bool netWasAllocated; + + void compileHalide() + { + CV_Assert(preferableBackend == DNN_BACKEND_HALIDE); + + HalideScheduler scheduler(halideConfigFile); + MapIdToLayerData::iterator it; + for (it = layers.begin(); it != layers.end(); ++it) + { + LayerData &ld = it->second; + Ptr layer = ld.layerInstance; + if (layer->supportBackend(DNN_BACKEND_HALIDE) && !ld.skipFlags[DNN_BACKEND_HALIDE]) + { + CV_Assert(!ld.backendNodes[DNN_BACKEND_HALIDE].empty()); + bool scheduled = scheduler.process(ld.backendNodes[DNN_BACKEND_HALIDE]); + if (!scheduled) + { + // Use automatic scheduling provided by layer. + layer->applyHalideScheduler(ld.backendNodes[DNN_BACKEND_HALIDE], + ld.inputBlobs, ld.outputBlobs, + preferableTarget); + } + dnn::compileHalide(ld.outputBlobs, ld.backendNodes[DNN_BACKEND_HALIDE], + preferableTarget); + } + } + } + + void clear() + { + MapIdToLayerData::iterator it; + for (it = layers.begin(); it != layers.end(); it++) + { + if (it->second.id != 0) { + it->second.outputBlobs.clear(); + it->second.internals.clear(); + } + it->second.skipFlags.clear(); + it->second.consumers.clear(); + Ptr convLayer = it->second.layerInstance.dynamicCast(); + + if( !convLayer.empty() ) + { + convLayer->setActivation(Ptr()); + convLayer->setBatchNorm(Ptr()); + } + + Ptr poolingLayer = it->second.layerInstance.dynamicCast(); + if( !poolingLayer.empty() ) + { + poolingLayer->computeMaxIdx = true; + } + } + } + + + void setUpNet(const std::vector& blobsToKeep_ = std::vector()) + { + if (!netWasAllocated || this->blobsToKeep != blobsToKeep_) + { + clear(); + + allocateLayers(blobsToKeep_); + computeNetOutputLayers(); + initBackend(); + + if (!netWasAllocated ) + { + // If user didn't call compileHalide() between + // setPreferableBackend(DNN_BACKEND_HALIDE) and forward(). + if (preferableBackend == DNN_BACKEND_HALIDE) + compileHalide(); + } + + netWasAllocated = true; + this->blobsToKeep = blobsToKeep_; + } + } + + int getLayerId(const String &layerName) + { + std::map::iterator it = layerNameToId.find(layerName); + return (it != layerNameToId.end()) ? it->second : -1; + } + + int getLayerId(int id) + { + MapIdToLayerData::iterator it = layers.find(id); + return (it != layers.end()) ? id : -1; + } + + int getLayerId(DictValue &layerDesc) + { + if (layerDesc.isInt()) + return getLayerId(layerDesc.get()); + else if (layerDesc.isString()) + return getLayerId(layerDesc.get()); + + CV_Assert(layerDesc.isInt() || layerDesc.isString()); + return -1; + } + + String getLayerName(int id) + { + MapIdToLayerData::iterator it = layers.find(id); + return (it != layers.end()) ? it->second.name : "(unknown layer)"; + } + + LayerData& getLayerData(int id) + { + MapIdToLayerData::iterator it = layers.find(id); + + if (it == layers.end()) + CV_Error(Error::StsObjectNotFound, format("Layer with requested id=%d not found", id)); + + return it->second; + } + + LayerData& getLayerData(const String &layerName) + { + int id = getLayerId(layerName); + + if (id < 0) + CV_Error(Error::StsError, "Requsted layer \"" + layerName + "\" not found"); + + return getLayerData(id); + } + + LayerData& getLayerData(const DictValue &layerDesc) + { + if (layerDesc.isInt()) + return getLayerData(layerDesc.get()); + else if (layerDesc.isString()) + return getLayerData(layerDesc.get()); + + CV_Assert(layerDesc.isInt() || layerDesc.isString()); + return *((LayerData*)NULL); + } + + static void addLayerInput(LayerData &ld, int inNum, LayerPin from) + { + if ((int)ld.inputBlobsId.size() <= inNum) + { + ld.inputBlobsId.resize(inNum + 1); + } + else + { + LayerPin storedFrom = ld.inputBlobsId[inNum]; + if (storedFrom.valid() && !storedFrom.equal(from)) + CV_Error(Error::StsError, "Input #" + toString(inNum) + "of layer \"" + ld.name + "\" already was connected"); + } + + ld.inputBlobsId[inNum] = from; + } + + static void splitPin(const String &pinAlias, String &layerName, String &outName) + { + size_t delimPos = pinAlias.find('.'); + layerName = pinAlias.substr(0, delimPos); + outName = (delimPos == String::npos) ? String() : pinAlias.substr(delimPos + 1); + } + + int resolvePinOutputName(LayerData &ld, const String &outName) + { + if (outName.empty()) + return 0; + + if (std::isdigit(outName[0])) + { + char *lastChar; + long inum = std::strtol(outName.c_str(), &lastChar, 10); + + if (*lastChar == 0) + { + CV_Assert(inum == (int)inum); + return (int)inum; + } + } + + return ld.getLayerInstance()->outputNameToIndex(outName); + } + + LayerPin getPinByAlias(const String &pinAlias) + { + LayerPin pin; + String layerName, outName; + splitPin(pinAlias, layerName, outName); + + pin.lid = (layerName.empty()) ? 0 : getLayerId(layerName); + + if (pin.lid >= 0) + pin.oid = resolvePinOutputName(getLayerData(pin.lid), outName); + + return pin; + } + + std::vector getLayerOutPins(const String &pinAlias) + { + String layerName, outName; + splitPin(pinAlias, layerName, outName); + + int lid = (layerName.empty()) ? 0 : getLayerId(layerName); + + std::vector pins; + + for (int i = 0; i < layers[lid].outputBlobs.size(); i++) + { + pins.push_back(LayerPin(lid, i)); + } + + return pins; + } + + void connect(int outLayerId, int outNum, int inLayerId, int inNum) + { + CV_Assert(outLayerId < inLayerId); + LayerData &ldOut = getLayerData(outLayerId); + LayerData &ldInp = getLayerData(inLayerId); + + addLayerInput(ldInp, inNum, LayerPin(outLayerId, outNum)); + ldOut.requiredOutputs.insert(outNum); + ldOut.consumers.push_back(LayerPin(inLayerId, outNum)); + } + + void computeNetOutputLayers() + { + netOutputs.clear(); + + MapIdToLayerData::iterator it; + for (it = layers.begin(); it != layers.end(); it++) + { + int lid = it->first; + LayerData &ld = it->second; + + if (ld.requiredOutputs.size() == 0) + netOutputs.push_back(lid); + } + + #ifndef NDEBUG + std::cout << "\nNet Outputs(" << netOutputs.size() << "):\n"; + for (size_t i = 0; i < netOutputs.size(); i++) + std::cout << layers[netOutputs[i]].name << "\n"; + #endif + } + + void initBackend() + { + backendWrapper.reset(); + if (preferableBackend == DNN_BACKEND_DEFAULT) + { + CV_Assert(preferableTarget == DNN_TARGET_CPU); + return; + } + + // Iterator to current layer. + MapIdToLayerData::iterator it = layers.begin(); + // Iterator to base layer for fusion. In example, in case of conv+bn+relu + // it'll be a conv layer. + MapIdToLayerData::iterator baseIt = layers.begin(); + for (; it != layers.end(); it++) + { + LayerData &ldTop = it->second; + Ptr layerTop = ldTop.layerInstance; + if (!layerTop->supportBackend(preferableBackend)) + { + // Move base iterator to layer that don't support preferable + // backend to prevent fusion over layer of different backend. + baseIt = it; + continue; + } + // Try to do layers fusion. + LayerData &ldBot = baseIt->second; + Ptr layerBot = ldBot.layerInstance; + // 1. Check that bottom and top from the same backends. + if (it != layers.begin() && layerBot->supportBackend(preferableBackend)) + { + // 2. Check that current layer works in-place. + bool inPlace = ldTop.inputBlobs.size() == 1 && + ldBot.outputBlobs.size() == 1 && + ldTop.inputBlobs[0]->data == + ldBot.outputBlobs[0].data; + if (inPlace) + { + // 3. Try to attach node. + CV_Assert(!ldBot.backendNodes[preferableBackend].empty()); + Ptr fusedNode = + layerTop->tryAttach(ldBot.backendNodes[preferableBackend]); + if (!fusedNode.empty()) + { + ldTop.skipFlags[preferableBackend] = true; + ldBot.backendNodes[preferableBackend] = fusedNode; + continue; + } + } + } + // No layers fusion. + ldTop.skipFlags[preferableBackend] = false; + std::vector > inputs = + backendWrapper.wrap(ldTop.inputBlobs, preferableBackend, + preferableTarget); + if (preferableBackend == DNN_BACKEND_HALIDE) + { + ldTop.backendNodes[DNN_BACKEND_HALIDE] = layerTop->initHalide(inputs); + baseIt = it; + } + else + { + CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); + } + } + } + + #define CV_RETHROW_ERROR(err, newmsg)\ + cv::error(err.code, newmsg, err.func.c_str(), err.file.c_str(), err.line) + + void allocateLayer(int lid, const LayersShapesMap& layersShapes) + { + LayerData &ld = layers[lid]; + + //already allocated + if (ld.flag) + return; + + size_t ninputs = ld.inputBlobsId.size(); +#if 0 + printf("layer %s:", ld.name.c_str()); + for (size_t i = 0; i < ninputs; i++) + { + int inp_lid = ld.inputBlobsId[i].lid; + LayerData &inp_ld = layers[inp_lid]; + int inp_outputs = (int)inp_ld.outputBlobs.size(); + std::cout << " " << inp_ld.name << "(" << inp_outputs; + + for( int j = 0; j < inp_outputs; j++ ) + { + std::cout << (j == 0 ? ": " : ", ") << inp_ld.outputBlobs[j].size; + } + std::cout << ")"; + } + printf("\n"); +#endif + + //determine parent layers + for (size_t i = 0; i < ninputs; i++) + ld.inputLayersId.insert(ld.inputBlobsId[i].lid); + + //allocate parents + for (set::iterator i = ld.inputLayersId.begin(); i != ld.inputLayersId.end(); i++) + allocateLayer(*i, layersShapes); + + //bind inputs + ld.inputBlobs.resize(ninputs); + for (size_t i = 0; i < ninputs; i++) + { + LayerPin from = ld.inputBlobsId[i]; + CV_Assert(from.valid()); + CV_DbgAssert(layers.count(from.lid) && (int)layers[from.lid].outputBlobs.size() > from.oid); + ld.inputBlobs[i] = &layers[from.lid].outputBlobs[from.oid]; + } + + LayersShapesMap::const_iterator layerShapesIt = layersShapes.find(lid); + + CV_Assert(layerShapesIt != layersShapes.end()); + + std::vector pinsForInternalBlobs; + blobManager.allocateBlobsForLayer(ld, layerShapesIt->second, pinsForInternalBlobs); + + Ptr layerPtr = ld.getLayerInstance(); + { + layerPtr->finalize(ld.inputBlobs, ld.outputBlobs); +#if 0 + std::cout << "\toutputs:"; + size_t noutputs = ld.outputBlobs.size(); + for (size_t j = 0; j < noutputs; j++) + { + std::cout << (j == 0 ? " " : ", ") << ld.outputBlobs[j].size; + } + std::cout << "\n"; +#endif + } + + // After allocation of layer, we decrease counters to it's input blobs. + blobManager.releaseReferences(ld.inputBlobsId); + blobManager.releaseReferences(pinsForInternalBlobs); + + ld.flag = 1; + } + + void fuseLayers(const std::vector& blobsToKeep_) + { + // scan through all the layers. If there is convolution layer followed by the activation layer, + // we try to embed this activation into the convolution and disable separate execution of the activation + std::vector outnames; + std::set pinsToKeep(blobsToKeep_.begin(), + blobsToKeep_.end()); + MapIdToLayerData::iterator it; + for (it = layers.begin(); it != layers.end(); it++) + { + int lid = it->first; + LayerData& ld = layers[lid]; + if( ld.skipFlags[DNN_BACKEND_DEFAULT] ) + { + continue; + } + if( ld.consumers.size() == 0 ) + outnames.push_back(ld.layerInstance->name); + Ptr convLayer = ld.layerInstance.dynamicCast(); + LayerPin lp(lid, 0); + if( !convLayer.empty() && ld.consumers.size() == 1 && + pinsToKeep.count(lp) == 0 ) + { + LayerData* nextData = &layers[ld.consumers[0].lid]; + Ptr nextBNormLayer = + nextData->layerInstance.dynamicCast(); + LayerPin lpNext(ld.consumers[0].lid, 0); + if( !nextBNormLayer.empty() && pinsToKeep.count(lpNext) == 0 ) + { + LayerData* bnormData = nextData; + nextData = 0; + if( convLayer->setBatchNorm(nextBNormLayer) ) + { + bnormData->skipFlags[DNN_BACKEND_DEFAULT] = true; + ld.outputBlobs = layers[lpNext.lid].outputBlobs; + if( bnormData->consumers.size() == 1 ) + nextData = &layers[bnormData->consumers[0].lid]; + } + } + + Ptr nextActivLayer; + if( nextData ) + nextActivLayer = nextData->layerInstance.dynamicCast(); + + if( !nextActivLayer.empty() && convLayer->setActivation(nextActivLayer) ) + { + nextData->skipFlags[DNN_BACKEND_DEFAULT] = true; + ld.outputBlobs = layers[lpNext.lid].outputBlobs; + } + } + Ptr poolingLayer = ld.layerInstance.dynamicCast(); + if( !poolingLayer.empty() && !ld.consumers.empty() ) + { + size_t i = 0, nconsumers = ld.consumers.size(); + for( ; i < nconsumers; i++ ) + if( ld.consumers[i].oid > 0 ) + break; + // if there is no layer that takes the second output pin of the pooling layer + // on input then we don't need to compute the indices + if( i >= nconsumers ) + poolingLayer->computeMaxIdx = false; + } + } + } + + void allocateLayers(const std::vector& blobsToKeep_) + { + MapIdToLayerData::iterator it; + for (it = layers.begin(); it != layers.end(); it++) + it->second.flag = 0; + + CV_Assert(!layers[0].outputBlobs.empty()); + ShapesVec inputShapes; + for(int i = 0; i < layers[0].outputBlobs.size(); i++) + { + CV_Assert(layers[0].outputBlobs[i].total()); + inputShapes.push_back(shape(layers[0].outputBlobs[i])); + } + LayersShapesMap layersShapes; + getLayersShapes(inputShapes, layersShapes); + + blobManager.reset(); + for (it = layers.begin(); it != layers.end(); ++it) + { + const LayerData& ld = it->second; + blobManager.addReferences(ld.inputBlobsId); + } + + for (int i = 0; i < blobsToKeep_.size(); i++) + { + blobManager.addReference(blobsToKeep_[i]); + } + + for (it = layers.begin(); it != layers.end(); it++) + { + int lid = it->first; + allocateLayer(lid, layersShapes); + } + + fuseLayers(blobsToKeep_); + } + + void forwardLayer(LayerData &ld) + { + Ptr layer = ld.layerInstance; + + if (preferableBackend == DNN_BACKEND_DEFAULT || + !layer->supportBackend(preferableBackend)) + { + if( !ld.skipFlags[DNN_BACKEND_DEFAULT] ) + layer->forward(ld.inputBlobs, ld.outputBlobs, ld.internals); + } + else if (!ld.skipFlags[preferableBackend]) + { + std::vector > outputs = + backendWrapper.wrap(ld.outputBlobs, preferableBackend, preferableTarget); + Ptr node = ld.backendNodes[preferableBackend]; + if (preferableBackend == DNN_BACKEND_HALIDE) + { + forwardHalide(outputs, node); + } + else + { + CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); + } + } + + ld.flag = 1; + } + + void forwardToLayer(LayerData &ld, bool clearFlags = true) + { + if (clearFlags) + { + MapIdToLayerData::iterator it; + for (it = layers.begin(); it != layers.end(); it++) + it->second.flag = 0; + } + + //already was forwarded + if (ld.flag) + return; + + //forward parents + MapIdToLayerData::iterator it; + for (it = layers.begin(); it->second.id < ld.id; it++) + { + LayerData &ld = it->second; + if (ld.flag) + continue; + forwardLayer(ld); + } + + //forward itself + forwardLayer(ld); + } + + void forwardAll() + { + forwardToLayer(layers.rbegin()->second, true); + } + + void getLayerShapesRecursively(int id, LayersShapesMap& inOutShapes) + { + std::vector& inputLayerIds = layers[id].inputBlobsId; + + if (inOutShapes[id].in.empty()) + { + for(int i = 0; i < inputLayerIds.size(); i++) + { + int layerId = inputLayerIds[i].lid; + LayersShapesMap::iterator it = + inOutShapes.find(layerId); + if(it == inOutShapes.end() || + it->second.out.empty()) + { + getLayerShapesRecursively(layerId, inOutShapes); + } + const MatShape& shape = inOutShapes[layerId].out[inputLayerIds[i].oid]; + inOutShapes[id].in.push_back(shape); + } + } + const ShapesVec& is = inOutShapes[id].in; + ShapesVec& os = inOutShapes[id].out; + ShapesVec& ints = inOutShapes[id].internal; + int requiredOutputs = layers[id].requiredOutputs.size(); + inOutShapes[id].supportInPlace = + layers[id].getLayerInstance()->getMemoryShapes(is, requiredOutputs, os, ints); + } + + void getLayersShapes(const ShapesVec& netInputShapes, + LayersShapesMap& inOutShapes) + { + inOutShapes.clear(); + + inOutShapes[0].in = netInputShapes; //insert shape for first input layer + for (MapIdToLayerData::iterator it = layers.begin(); + it != layers.end(); it++) + { + getLayerShapesRecursively(it->first, inOutShapes); + } + } + + void getLayerShapes(const ShapesVec& netInputShapes, + const int layerId, + LayerShapes& shapes) + { + LayersShapesMap inOutShapes; + inOutShapes[0].in = netInputShapes; //insert shape for first input layer + getLayerShapesRecursively(layerId, inOutShapes); + shapes = inOutShapes[layerId]; + } + + LayerPin getLatestLayerPin(const std::vector& pins) + { + return *std::max_element(pins.begin(), pins.end()); + } + + Mat getBlob(const LayerPin& pin) + { + if (!pin.valid()) + CV_Error(Error::StsObjectNotFound, "Requested blob not found"); + + LayerData &ld = layers[pin.lid]; + if ((size_t)pin.oid >= ld.outputBlobs.size()) + { + CV_Error(Error::StsOutOfRange, "Layer \"" + ld.name + "\" produce only " + toString(ld.outputBlobs.size()) + + " outputs, the #" + toString(pin.oid) + " was requsted"); + } + if (preferableBackend != DNN_BACKEND_DEFAULT) + { + // Transfer data to CPU if it's require. + backendWrapper.wrap(ld.outputBlobs[pin.oid], preferableBackend, + preferableTarget)->copyToHost(); + } + else + { + CV_Assert(preferableTarget == DNN_TARGET_CPU); + } + return ld.outputBlobs[pin.oid]; + } + + Mat getBlob(String outputName) + { + return getBlob(getPinByAlias(outputName)); + } +}; + +Net::Net() : impl(new Net::Impl) +{ +} + +Net::~Net() +{ +} + +int Net::addLayer(const String &name, const String &type, LayerParams ¶ms) +{ + if (name.find('.') != String::npos) + { + CV_Error(Error::StsBadArg, "Added layer name \"" + name + "\" must not contain dot symbol"); + return -1; + } + + if (impl->getLayerId(name) >= 0) + { + CV_Error(Error::StsBadArg, "Layer \"" + name + "\" already into net"); + return -1; + } + + int id = ++impl->lastLayerId; + impl->layerNameToId.insert(std::make_pair(name, id)); + impl->layers.insert(std::make_pair(id, LayerData(id, name, type, params))); + + return id; +} + +int Net::addLayerToPrev(const String &name, const String &type, LayerParams ¶ms) +{ + int prvLid = impl->lastLayerId; + int newLid = this->addLayer(name, type, params); + this->connect(prvLid, 0, newLid, 0); + return newLid; +} + +void Net::connect(int outLayerId, int outNum, int inpLayerId, int inpNum) +{ + impl->connect(outLayerId, outNum, inpLayerId, inpNum); +} + +void Net::connect(String _outPin, String _inPin) +{ + LayerPin outPin = impl->getPinByAlias(_outPin); + LayerPin inpPin = impl->getPinByAlias(_inPin); + + CV_Assert(outPin.valid() && inpPin.valid()); + + impl->connect(outPin.lid, outPin.oid, inpPin.lid, inpPin.oid); +} + +Mat Net::forward(const String& outputName) +{ + String layerName = outputName; + + if (layerName.empty()) + layerName = getLayerNames().back(); + + impl->setUpNet(); + impl->forwardToLayer(impl->getLayerData(layerName)); + + return impl->getBlob(layerName); +} + +void Net::forward(std::vector& outputBlobs, const String& outputName) +{ + impl->setUpNet(); + + String layerName = outputName; + + if (layerName.empty()) + layerName = getLayerNames().back(); + + impl->forwardToLayer(impl->getLayerData(layerName)); + + LayerPin pin = impl->getPinByAlias(layerName); + LayerData &ld = impl->layers[pin.lid]; + outputBlobs = ld.outputBlobs; +} + +void Net::forward(std::vector& outputBlobs, + const std::vector& outBlobNames) +{ + std::vector pins; + for (int i = 0; i < outBlobNames.size(); i++) + { + pins.push_back(impl->getPinByAlias(outBlobNames[i])); + } + + impl->setUpNet(pins); + + LayerPin out = impl->getLatestLayerPin(pins); + + impl->forwardToLayer(impl->getLayerData(out.lid)); + + outputBlobs.clear(); + for (int i = 0; i < pins.size(); i++) + { + outputBlobs.push_back(impl->getBlob(pins[i])); + } +} + +void Net::forward(std::vector >& outputBlobs, + const std::vector& outBlobNames) +{ + std::vector pins; + for (int i = 0; i < outBlobNames.size(); i++) + { + std::vector lp = impl->getLayerOutPins(outBlobNames[i]); + pins.insert(pins.end(), lp.begin(), lp.end()); + } + + impl->setUpNet(pins); + + LayerPin out = impl->getLatestLayerPin(pins); + + impl->forwardToLayer(impl->getLayerData(out.lid)); + + outputBlobs.resize(outBlobNames.size()); + for (int i = 0; i < outBlobNames.size(); i++) + { + std::vector lp = impl->getLayerOutPins(outBlobNames[i]); + for (int i = 0; i < lp.size(); i++) + { + outputBlobs[i].push_back(impl->getBlob(lp[i])); + } + } +} + +void Net::setPreferableBackend(int backendId) +{ + impl->netWasAllocated = impl->netWasAllocated && + impl->preferableBackend == backendId; + impl->preferableBackend = backendId; +} + +void Net::setPreferableTarget(int targetId) +{ + impl->netWasAllocated = impl->netWasAllocated && + impl->preferableTarget == targetId; + impl->preferableTarget = targetId; +} + +void Net::setInputsNames(const std::vector &inputBlobNames) +{ + impl->netInputLayer->setNames(inputBlobNames); +} + +void Net::setInput(const Mat &blob_, const String& name) +{ + LayerPin pin; + pin.lid = 0; + pin.oid = impl->resolvePinOutputName(impl->getLayerData(pin.lid), name); + + if (!pin.valid()) + CV_Error(Error::StsObjectNotFound, "Requested blob \"" + name + "\" not found"); + + LayerData &ld = impl->layers[pin.lid]; + ld.outputBlobs.resize( std::max(pin.oid+1, (int)ld.requiredOutputs.size()) ); + MatShape prevShape = shape(ld.outputBlobs[pin.oid]); + bool oldShape = prevShape == shape(blob_); + if (oldShape) + blob_.copyTo(ld.outputBlobs[pin.oid]); + else + ld.outputBlobs[pin.oid] = blob_.clone(); + + impl->netWasAllocated = impl->netWasAllocated && oldShape; +} + +Mat Net::getParam(LayerId layer, int numParam) +{ + LayerData &ld = impl->getLayerData(layer); + + std::vector &layerBlobs = ld.layerInstance->blobs; + CV_Assert(numParam < (int)layerBlobs.size()); + return layerBlobs[numParam]; +} + +void Net::setParam(LayerId layer, int numParam, const Mat &blob) +{ + LayerData &ld = impl->getLayerData(layer); + + std::vector &layerBlobs = ld.layerInstance->blobs; + CV_Assert(numParam < (int)layerBlobs.size()); + //we don't make strong checks, use this function carefully + layerBlobs[numParam] = blob; +} + +int Net::getLayerId(const String &layer) +{ + return impl->getLayerId(layer); +} + +void Net::deleteLayer(LayerId) +{ + CV_Error(Error::StsNotImplemented, ""); +} + +Ptr Net::getLayer(LayerId layerId) +{ + LayerData &ld = impl->getLayerData(layerId); + if (!ld.layerInstance) + CV_Error(Error::StsNullPtr, format("Requested layer \"%s\" was not initialized", ld.name.c_str())); + return ld.layerInstance; +} + +std::vector > Net::getLayerInputs(LayerId layerId) +{ + LayerData &ld = impl->getLayerData(layerId); + if (!ld.layerInstance) + CV_Error(Error::StsNullPtr, format("Requested layer \"%s\" was not initialized", ld.name.c_str())); + + std::vector > inputLayers; + inputLayers.reserve(ld.inputLayersId.size()); + std::set::iterator it; + for (it = ld.inputLayersId.begin(); it != ld.inputLayersId.end(); ++it) { + inputLayers.push_back(getLayer(*it)); + } + return inputLayers; +} + +std::vector Net::getLayerNames() const +{ + std::vector res; + res.reserve(impl->layers.size()); + + Impl::MapIdToLayerData::iterator it; + for (it = impl->layers.begin(); it != impl->layers.end(); it++) + { + if (it->second.id) //skip Data layer + res.push_back(it->second.name); + } + + return res; +} + +bool Net::empty() const +{ + return impl->layers.size() <= 1; //first layer is default Data layer +} + +std::vector Net::getUnconnectedOutLayers() const +{ + std::vector layersIds; + + Impl::MapIdToLayerData::iterator it; + for (it = impl->layers.begin(); it != impl->layers.end(); it++) + { + int lid = it->first; + LayerData &ld = it->second; + + if (ld.requiredOutputs.size() == 0) + layersIds.push_back(lid); + } + + return layersIds; +} + +void Net::getLayersShapes(const ShapesVec& netInputShapes, + std::vector* layersIds, + std::vector* inLayersShapes, + std::vector* outLayersShapes) const +{ + if ((layersIds || inLayersShapes || outLayersShapes) == false) + return; + + if (layersIds) layersIds->clear(); + if (inLayersShapes) inLayersShapes->clear(); + if (outLayersShapes) outLayersShapes->clear(); + + Impl::LayersShapesMap inOutShapes; + impl->getLayersShapes(netInputShapes, inOutShapes); + + for(Impl::LayersShapesMap::const_iterator it = inOutShapes.begin(); + it != inOutShapes.end(); it++) + { + if (layersIds) + layersIds->push_back(it->first); + if (inLayersShapes) + inLayersShapes->push_back(it->second.in); + if (outLayersShapes) + outLayersShapes->push_back(it->second.out); + } +} + +void Net::getLayersShapes(const MatShape& netInputShape, + std::vector* layerIds, + std::vector* inLayersShapes, + std::vector* outLayersShapes) const +{ + getLayersShapes(ShapesVec(1, netInputShape), + layerIds, inLayersShapes, outLayersShapes); +} + +void Net::getLayerShapes(const MatShape& netInputShape, + const int layerId, + ShapesVec* inLayerShapes, + ShapesVec* outLayerShapes) const +{ + getLayerShapes(ShapesVec(1, netInputShape), + layerId, inLayerShapes, outLayerShapes); + +} + +void Net::getLayerShapes(const ShapesVec& netInputShapes, + const int layerId, + ShapesVec* inLayerShapes, + ShapesVec* outLayerShapes) const +{ + LayerShapes shapes; + impl->getLayerShapes(netInputShapes, layerId, shapes); + if (inLayerShapes) + *inLayerShapes = shapes.in; + if (outLayerShapes) + *outLayerShapes = shapes.out; +} + +int64 Net::getFLOPS(const std::vector& netInputShapes) const +{ + int64 flops = 0; + std::vector ids; + std::vector > inShapes, outShapes; + getLayersShapes(netInputShapes, &ids, &inShapes, &outShapes); + CV_Assert(inShapes.size() == outShapes.size()); + CV_Assert(inShapes.size() == ids.size()); + + for(int i = 0; i < ids.size(); i++) + { + flops += impl->layers[ids[i]].getLayerInstance()->getFLOPS(inShapes[i], + outShapes[i]); + } + + return flops; +} + +int64 Net::getFLOPS(const MatShape& netInputShape) const +{ + return getFLOPS(std::vector(1, netInputShape)); +} + +int64 Net::getFLOPS(const int layerId, + const std::vector& netInputShapes) const +{ + Impl::MapIdToLayerData::iterator layer = impl->layers.find(layerId); + CV_Assert(layer != impl->layers.end()); + + LayerShapes shapes; + impl->getLayerShapes(netInputShapes, layerId, shapes); + + return layer->second.getLayerInstance()->getFLOPS(shapes.in, shapes.out); +} + +int64 Net::getFLOPS(const int layerId, + const MatShape& netInputShape) const +{ + return getFLOPS(layerId, std::vector(1, netInputShape)); +} + +void Net::getLayerTypes(std::vector& layersTypes) const +{ + layersTypes.clear(); + + std::map layers; + for (Impl::MapIdToLayerData::iterator it = impl->layers.begin(); + it != impl->layers.end(); it++) + { + if (layers.find(it->second.type) == layers.end()) + layers[it->second.type] = 0; + layers[it->second.type]++; + } + + for (std::map::iterator it = layers.begin(); + it != layers.end(); it++) + { + layersTypes.push_back(it->first); + } +} + +int Net::getLayersCount(const String& layerType) const +{ + int count = 0; + for (Impl::MapIdToLayerData::iterator it = impl->layers.begin(); + it != impl->layers.end(); it++) + { + if (it->second.type == layerType) + count++; + } + return count; +} + +void Net::getMemoryConsumption(const int layerId, + const std::vector& netInputShapes, + size_t& weights, size_t& blobs) const +{ + Impl::MapIdToLayerData::iterator layer = impl->layers.find(layerId); + CV_Assert(layer != impl->layers.end()); + + weights = blobs = 0; + + for(int i = 0; i < layer->second.params.blobs.size(); i++) + { + const Mat& weightsBlob = layer->second.params.blobs[i]; + weights += weightsBlob.total()*weightsBlob.elemSize(); + } + + std::vector outLayerShapes; + getLayerShapes(netInputShapes, layerId, 0, &outLayerShapes); + for(int i = 0; i < outLayerShapes.size(); i++) + { + blobs += total(outLayerShapes[i]) * sizeof(float); + } +} + +void Net::getMemoryConsumption(const std::vector& netInputShapes, + size_t& weights, size_t& blobs) const +{ + std::vector layerIds; + std::vector w, b; + getMemoryConsumption(netInputShapes, layerIds, w, b); + + weights = blobs = 0; + for(int i = 0; i < layerIds.size(); i++) + { + weights += w[i]; + blobs += b[i]; + } +} + +void Net::getMemoryConsumption(const int layerId, + const MatShape& netInputShape, + size_t& weights, size_t& blobs) const +{ + getMemoryConsumption(layerId, std::vector(1, netInputShape), + weights, blobs); +} + +void Net::getMemoryConsumption(const MatShape& netInputShape, + size_t& weights, size_t& blobs) const +{ + getMemoryConsumption(std::vector(1, netInputShape), + weights, blobs); +} + +void Net::getMemoryConsumption(const std::vector& netInputShapes, + std::vector& layerIds, std::vector& weights, + std::vector& blobs) const +{ + layerIds.clear(); + weights.clear(); + blobs.clear(); + + std::vector > outLayerShapes; + + getLayersShapes(netInputShapes, &layerIds, 0, &outLayerShapes); + + for(int i = 0; i < layerIds.size(); i++) + { + int w = 0, b = 0; + Impl::MapIdToLayerData::iterator layer = impl->layers.find(layerIds[i]); + CV_Assert(layer != impl->layers.end()); + + for(int j = 0; j < layer->second.params.blobs.size(); j++) + { + const Mat& weightsBlob = layer->second.params.blobs[j]; + w += weightsBlob.total()*weightsBlob.elemSize(); + } + + for(int j = 0; j < outLayerShapes[i].size(); j++) + { + b += total(outLayerShapes[i][j]) * sizeof(float); + } + + weights.push_back(w); + blobs.push_back(b); + } +} + +void Net::getMemoryConsumption(const MatShape& netInputShape, std::vector& layerIds, + std::vector& weights, std::vector& blobs) const +{ + getMemoryConsumption(std::vector(1, netInputShape), layerIds, + weights, blobs); +} + +void Net::setHalideScheduler(const String& scheduler) +{ + impl->halideConfigFile = scheduler; +} + +////////////////////////////////////////////////////////////////////////// + +Importer::~Importer() {} + +Layer::Layer() {} + +Layer::Layer(const LayerParams ¶ms) + : blobs(params.blobs), name(params.name), type(params.type) +{ + +} + +void Layer::setParamsFrom(const LayerParams ¶ms) +{ + blobs = params.blobs; + name = params.name; + type = params.type; +} + +int Layer::inputNameToIndex(String) +{ + return -1; +} + +int Layer::outputNameToIndex(String) +{ + return -1; +} + +bool Layer::supportBackend(int backendId) +{ + return backendId == DNN_BACKEND_DEFAULT; +} + +Ptr Layer::initHalide(const std::vector > &) +{ + CV_Error(Error::StsNotImplemented, "Halide pipeline of " + type + + " layers is not defined."); + return Ptr(); +} + +void Layer::applyHalideScheduler(Ptr& node, const std::vector &inputs, + const std::vector &outputs, int targetId) const +{ +#ifdef HAVE_HALIDE + Halide::Var x("x"), y("y"), c("c"), n("n"), co("co"), ci("ci"), + xo("xo"), xi("xi"), yo("yo"), yi("yi"), tile("tile"); + Halide::Func& top = node.dynamicCast()->funcs.back(); + + int outW, outH, outC, outN; + getCanonicalSize(outputs[0].size, &outW, &outH, &outC, &outN); + + if (targetId == DNN_TARGET_CPU) + { + if (outW == 1 && outH == 1) + { + if (outC + outN == 1) + return; + + if (outC > 8) + top.split(c, co, ci, 8) + .fuse(x, y, tile).fuse(co, tile, tile).fuse(n, tile, tile) + .parallel(tile) + .vectorize(ci, 8); + else + top.fuse(x, y, tile).fuse(c, tile, tile).fuse(n, tile, tile) + .parallel(tile); + } + else + { + if (outH > 2) + { + top.reorder(x, c, y) + .split(y, yo, yi, 2) + .fuse(yo, n, tile) + .parallel(tile) + .unroll(yi) + .vectorize(x, outW >= 16 ? 16 : outW); + } + } + } + else if (targetId == DNN_TARGET_OPENCL) + { + int c_split = outC > 8 ? (outC > 16 ? 8 : 4) : outC; + if (outW == 1 && outH == 1) + { + top.split(c, co, ci, c_split) + .fuse(x, y, tile).fuse(co, tile, tile).fuse(n, tile, tile) + .gpu_blocks(tile) + .gpu_threads(ci); + } + else + { + int x_split = outW > 8 ? (outW >= 32 ? 16 : 8) : outW; + int y_split = outH > 8 ? (outH >= 32 ? 16 : 8) : outH; + top.split(x, xo, xi, x_split).split(y, yo, yi, y_split) + .split(c, co, ci, c_split) + .gpu_blocks(xo, yo, co) + .gpu_threads(xi, yi) + .reorder(xi, yi, ci, xo, yo, co) + .vectorize(ci); + } + } + else + CV_Error(Error::StsNotImplemented, "Unknown target identifier"); +#endif // HAVE_HALIDE +} + +Ptr Layer::tryAttach(const Ptr& node) +{ + return Ptr(); +} + +template +static void vecToPVec(const std::vector &v, std::vector &pv) +{ + pv.resize(v.size()); + for (size_t i = 0; i < v.size(); i++) + pv[i] = const_cast(&v[i]); +} + +void Layer::finalize(const std::vector &inputs, std::vector &outputs) +{ + std::vector inputsp; + vecToPVec(inputs, inputsp); + this->finalize(inputsp, outputs); +} + +void Layer::finalize(const std::vector &input, std::vector &output) +{ + (void)input;(void)output; +} + +std::vector Layer::finalize(const std::vector &inputs) +{ + std::vector outputs; + this->finalize(inputs, outputs); + return outputs; +} + +void Layer::forward(const std::vector &inputs, std::vector &outputs, std::vector &internals) +{ + std::vector inputsp; + vecToPVec(inputs, inputsp); + this->forward(inputsp, outputs, internals); +} + +void Layer::run(const std::vector &inputs, std::vector &outputs, std::vector &internals) +{ + std::vector inputsp; + vecToPVec(inputs, inputsp); + this->finalize(inputsp, outputs); + this->forward(inputsp, outputs, internals); +} + +Layer::~Layer() {} + +bool Layer::getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const +{ + CV_Assert(inputs.size()); + outputs.assign(std::max(requiredOutputs, (int)inputs.size()), inputs[0]); + return false; +} + +////////////////////////////////////////////////////////////////////////// + +struct LayerFactory::Impl : public std::map +{ +}; + +Ptr LayerFactory::impl () +{ + // allocate on first use + static Ptr impl_(new LayerFactory::Impl()); + return impl_; +} + +void LayerFactory::registerLayer(const String &_type, Constuctor constructor) +{ + String type = _type.toLowerCase(); + Impl::iterator it = impl()->find(type); + + if (it != impl()->end() && it->second != constructor) + { + CV_Error(cv::Error::StsBadArg, "Layer \"" + type + "\" already was registered"); + } + + impl()->insert(std::make_pair(type, constructor)); +} + +void LayerFactory::unregisterLayer(const String &_type) +{ + String type = _type.toLowerCase(); + impl()->erase(type); +} + +Ptr LayerFactory::createLayerInstance(const String &_type, LayerParams& params) +{ + String type = _type.toLowerCase(); + Impl::const_iterator it = LayerFactory::impl()->find(type); + + if (it != impl()->end()) + { + return it->second(params); + } + else + { + return Ptr(); //NULL + } +} + +BackendNode::BackendNode(int backendId) : backendId(backendId) {} + +BackendNode::~BackendNode() {}; + +BackendWrapper::BackendWrapper(int backendId, int targetId) + : backendId(backendId), targetId(targetId) {} + +BackendWrapper::BackendWrapper(int targetId, const cv::Mat& m) +{ + CV_Error(Error::StsNotImplemented, + "Constructor of backend wrapper must be implemented"); +} + +BackendWrapper::BackendWrapper(const Ptr& base, const MatShape& shape) +{ + CV_Error(Error::StsNotImplemented, + "Constructor of backend wrapper must be implemented"); +} + +BackendWrapper::~BackendWrapper() {} + +} +} diff --git a/modules/dnn/src/halide_scheduler.cpp b/modules/dnn/src/halide_scheduler.cpp new file mode 100644 index 0000000000..b7f748ff7a --- /dev/null +++ b/modules/dnn/src/halide_scheduler.cpp @@ -0,0 +1,284 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "halide_scheduler.hpp" +#include "op_halide.hpp" + +namespace cv +{ +namespace dnn +{ + +#ifdef HAVE_HALIDE +static void applySplit(const FileNode& directive, Halide::Func& func, + const FileNode& params) +{ + for (const auto& varNode : directive) + { + const std::string varName = varNode.name(); + const std::string factorName = (std::string)varNode; + Halide::Var var(varName); + Halide::Var outerVar(varName + "o"); + Halide::Var innerVar(varName + "i"); + // If split factor is integer or parameters map has parameter value. + CV_Assert(varNode.isString() && !params[factorName].empty() || + varNode.isInt()); + int factor = (int)(varNode.isInt() ? varNode : params[factorName]); + func.split(var, outerVar, innerVar, factor); + } +} + +static void applyReorder(const FileNode& directive, Halide::Func& func) +{ + std::string varName; + const int numVars = directive.size(); + std::vector reorderedVars; + reorderedVars.reserve(numVars); + for (int i = 0; i < numVars; ++i) + { + directive[i] >> varName; + reorderedVars.push_back(Halide::Var(varName)); + } + func.reorder(reorderedVars); +} + +static void applyFuse(const FileNode& directive, Halide::Func& func) +{ + CV_Assert(directive["src"].size() >= 2); + CV_Assert(directive["dst"].size() == 1); + + std::string str; + directive["src"][0] >> str; + Halide::Var firstVar(str); + directive["src"][1] >> str; + Halide::Var secondVar(str); + directive["dst"] >> str; + Halide::Var dstVar(str); + + func.fuse(firstVar, secondVar, dstVar); + for (int i = 2, n = directive["src"].size(); i < n; ++i) + { + directive["src"][i] >> str; + func.fuse(Halide::Var(str), dstVar, dstVar); + } +} + +static void applyParallel(const FileNode& directive, Halide::Func& func) +{ + std::string varName; + for (int i = 0, n = directive.size(); i < n; ++i) + { + directive[i] >> varName; + func.parallel(Halide::Var(varName)); + } +} + +static void applyUnroll(const FileNode& directive, Halide::Func& func) +{ + std::string varName; + for (int i = 0, n = directive.size(); i < n; ++i) + { + directive[i] >> varName; + func.unroll(Halide::Var(varName)); + } +} + +static void applyVectorize(const FileNode& directive, Halide::Func& func, + const FileNode& params) +{ + for (const auto& varNode : directive) + { + const std::string varName = varNode.name(); + const std::string factorName = (std::string)varNode; + // If split factor is integer or parameters map has parameter value. + CV_Assert(varNode.isString() && !params[factorName].empty() || + varNode.isInt()); + int factor = (int)(varNode.isInt() ? varNode : params[factorName]); + Halide::Var var(varName); + Halide::Var inner(varName + "v"); + func.split(var, var, inner, factor); + func.vectorize(inner); + } +} + +static void applyStoreAt(const FileNode& directive, Halide::Func& func, + std::map& funcsMap) +{ + for (const auto& funcNode : directive) + { + const std::string targetFuncName = funcNode.name(); + if (funcsMap.find(targetFuncName) == funcsMap.end()) + CV_Error(cv::Error::StsParseError, "Function " + targetFuncName + + " is not represented in Halide pipeline"); + Halide::Func targetFunc = funcsMap[targetFuncName]; + func.store_at(targetFunc, (std::string)funcNode); + break; + } +} + +static void applyComputeAt(const FileNode& directive, Halide::Func& func, + std::map& funcsMap) +{ + for (const auto& funcNode : directive) + { + const std::string targetFuncName = funcNode.name(); + if (funcsMap.find(targetFuncName) == funcsMap.end()) + CV_Error(cv::Error::StsParseError, "Function " + targetFuncName + + " is not represented in Halide pipeline"); + Halide::Func targetFunc = funcsMap[targetFuncName]; + func.compute_at(targetFunc, (std::string)funcNode); + break; + } +} + +static void applyComputeRoot(const FileNode& directive, Halide::Func& func) +{ + bool compute_root; + directive >> compute_root; + if (compute_root) + func.compute_root(); +} + +static void applyGpuBlocks(const FileNode& directive, Halide::Func& func) +{ + std::string varName; + for (int i = 0, n = directive.size(); i < n; ++i) + { + directive[i] >> varName; + func.gpu_blocks(Halide::Var(varName)); + } +} + +static void applyGpuThreads(const FileNode& directive, Halide::Func& func) +{ + std::string varName; + for (int i = 0, n = directive.size(); i < n; ++i) + { + directive[i] >> varName; + func.gpu_threads(Halide::Var(varName)); + } +} + +static void apply(const FileNode& directives, Halide::Func& func, + std::map& funcsMap, + const FileNode& params) +{ + for (const auto& directive : directives) + { + if (directive.name() == "split") + applySplit(directive, func, params); + else if (directive.name() == "reorder") + applyReorder(directive, func); + else if (directive.name() == "fuse") + applyFuse(directive, func); + else if (directive.name() == "parallel") + applyParallel(directive, func); + else if (directive.name() == "unroll") + applyUnroll(directive, func); + else if (directive.name() == "vectorize") + applyVectorize(directive, func, params); + else if (directive.name() == "store_at") + applyStoreAt(directive, func, funcsMap); + else if (directive.name() == "compute_at") + applyComputeAt(directive, func, funcsMap); + else if (directive.name() == "compute_root") + applyComputeRoot(directive, func); + else if (directive.name() == "gpu_blocks") + applyGpuBlocks(directive, func); + else if (directive.name() == "gpu_threads") + applyGpuThreads(directive, func); + else + CV_Error(Error::StsNotImplemented, "Scheduling directive " + + directive.name() + " is not implemented."); + } +} + +// Remove any numeric symbols after '$' sign. +static std::string Deunique(std::string str) +{ + int pos = -1; + do + { + pos = str.find('$'); + if (pos != -1) + { + int len = str.find_first_not_of("0123456789", pos + 1) - pos; + str = str.replace(pos, len, ""); + } + } + while (pos != -1); + return str; +} +#endif // HAVE_HALIDE + +HalideScheduler::HalideScheduler(const std::string& configFile) +{ + if (!configFile.empty()) + fs = FileStorage(configFile, FileStorage::READ); +} + +HalideScheduler::~HalideScheduler() +{ + if (fs.isOpened()) + fs.release(); +} + +bool HalideScheduler::process(Ptr& node) +{ +#ifdef HAVE_HALIDE + if (!fs.isOpened()) + return false; + + const FileNode& scheduleNode = fs["scheduling"]; + if (scheduleNode.empty()) + CV_Error(cv::Error::StsParseError, "Scheduling file should has scheduling node"); + + std::string str; + std::map funcsMap; // Scheduled functions. + // For every function, from top to bottom, we try to find a scheduling node. + // Scheduling is successful (return true) if for the first function (top) + // node is respresented. + CV_Assert(!node.empty()); + std::vector& funcs = node.dynamicCast()->funcs; + for (int i = funcs.size() - 1; i >= 0; --i) + { + Halide::Func& func = funcs[i]; + // For functions with the same name Halide generates unique names + // for example func, func$1, func$2. + // They are always formed with '$' and number. + std::string funcName = Deunique(func.name()); + + const FileNode& funcNode = scheduleNode[funcName]; + if (!funcNode.empty()) + { + if (!funcNode["pattern"].empty()) + { + funcNode["pattern"] >> str; + if (fs["patterns"][str].empty()) + CV_Error(cv::Error::StsParseError, "Scheduling pattern " + str + + " is not defined"); + apply(fs["patterns"][str], func, funcsMap, funcNode["params"]); + } + else + { + apply(funcNode, func, funcsMap, funcNode["params"]); + } + } + else + { + if (funcsMap.empty()) + return false; + } + funcsMap[funcName] = func; + } + return true; +#endif // HAVE_HALIDE + return false; +} + +} // namespace dnn +} // namespace cv diff --git a/modules/dnn/src/halide_scheduler.hpp b/modules/dnn/src/halide_scheduler.hpp new file mode 100644 index 0000000000..9afef3023f --- /dev/null +++ b/modules/dnn/src/halide_scheduler.hpp @@ -0,0 +1,37 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef __OPENCV_DNN_HALIDE_SCHEDULER_HPP__ +#define __OPENCV_DNN_HALIDE_SCHEDULER_HPP__ + +#include + +namespace cv +{ +namespace dnn +{ + +class HalideScheduler +{ +public: + HalideScheduler(const std::string& configFile); + + ~HalideScheduler(); + + // Returns true if pipeline found in scheduling file. + // If more than one function, returns true if the top function scheduled. + // Other functions are optional to scheduling. + bool process(Ptr& node); + +private: + FileStorage fs; +}; + +} // namespace dnn +} // namespace cv + +#endif // __OPENCV_DNN_HALIDE_SCHEDULER_HPP__ diff --git a/modules/dnn/src/init.cpp b/modules/dnn/src/init.cpp new file mode 100644 index 0000000000..5ece907b77 --- /dev/null +++ b/modules/dnn/src/init.cpp @@ -0,0 +1,107 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "precomp.hpp" + +namespace cv +{ +namespace dnn +{ + +struct AutoInitializer +{ + bool status; + + AutoInitializer() : status(false) + { + initModule(); + } +}; + +static AutoInitializer init; + +void initModule() +{ + if (init.status) + return; + + REG_RUNTIME_LAYER_CLASS(Slice, SliceLayer); + REG_RUNTIME_LAYER_CLASS(Split, SplitLayer); + REG_RUNTIME_LAYER_CLASS(Concat, ConcatLayer); + REG_RUNTIME_LAYER_CLASS(Reshape, ReshapeLayer); + REG_RUNTIME_LAYER_CLASS(Flatten, FlattenLayer); + + REG_RUNTIME_LAYER_CLASS(Convolution, ConvolutionLayer); + REG_RUNTIME_LAYER_CLASS(Deconvolution, DeconvolutionLayer); + REG_RUNTIME_LAYER_CLASS(Pooling, PoolingLayer); + REG_RUNTIME_LAYER_CLASS(LRN, LRNLayer); + REG_RUNTIME_LAYER_CLASS(InnerProduct, InnerProductLayer); + REG_RUNTIME_LAYER_CLASS(Softmax, SoftmaxLayer); + REG_RUNTIME_LAYER_CLASS(MVN, MVNLayer); + + REG_RUNTIME_LAYER_CLASS(ReLU, ReLULayer); + REG_RUNTIME_LAYER_CLASS(ChannelsPReLU, ChannelsPReLULayer); + REG_RUNTIME_LAYER_CLASS(Sigmoid, SigmoidLayer); + REG_RUNTIME_LAYER_CLASS(TanH, TanHLayer); + REG_RUNTIME_LAYER_CLASS(BNLL, BNLLLayer); + REG_RUNTIME_LAYER_CLASS(AbsVal, AbsLayer); + REG_RUNTIME_LAYER_CLASS(Power, PowerLayer); + REG_RUNTIME_LAYER_CLASS(BatchNorm, BatchNormLayer); + REG_RUNTIME_LAYER_CLASS(MaxUnpool, MaxUnpoolLayer); + REG_RUNTIME_LAYER_CLASS(Dropout, BlankLayer); + REG_RUNTIME_LAYER_CLASS(Identity, BlankLayer); + + REG_RUNTIME_LAYER_CLASS(Crop, CropLayer); + REG_RUNTIME_LAYER_CLASS(Eltwise, EltwiseLayer); + REG_RUNTIME_LAYER_CLASS(Permute, PermuteLayer); + REG_RUNTIME_LAYER_CLASS(PriorBox, PriorBoxLayer); + REG_RUNTIME_LAYER_CLASS(DetectionOutput, DetectionOutputLayer); + REG_RUNTIME_LAYER_CLASS(NormalizeBBox, NormalizeBBoxLayer); + REG_RUNTIME_LAYER_CLASS(Normalize, NormalizeBBoxLayer); + REG_RUNTIME_LAYER_CLASS(Shift, ShiftLayer); + REG_RUNTIME_LAYER_CLASS(Padding, PaddingLayer); + REG_RUNTIME_LAYER_CLASS(Scale, ScaleLayer); + + init.status = true; +} + +} +} diff --git a/modules/dnn/src/layers/batch_norm_layer.cpp b/modules/dnn/src/layers/batch_norm_layer.cpp new file mode 100644 index 0000000000..3b42230097 --- /dev/null +++ b/modules/dnn/src/layers/batch_norm_layer.cpp @@ -0,0 +1,198 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Implementation of Batch Normalization layer. +*/ + +#include "../precomp.hpp" +#include "op_halide.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class BatchNormLayerImpl : public BatchNormLayer +{ +public: + Mat weights_, bias_; + + BatchNormLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + CV_Assert(blobs.size() >= 3); + + hasWeights = params.get("has_weight", false); + hasBias = params.get("has_bias", false); + epsilon = params.get("eps", 1E-5); + + size_t n = blobs[0].total(); + CV_Assert(blobs[1].total() == n && + blobs[0].isContinuous() && blobs[1].isContinuous() && + blobs[0].type() == CV_32F && blobs[1].type() == CV_32F); + + float varMeanScale = 1.f; + if (!hasWeights && !hasBias) { + CV_Assert(blobs[2].type() == CV_32F); + varMeanScale = blobs[2].at(0); + if (varMeanScale != 0) + varMeanScale = 1/varMeanScale; + } + + const int weightsBlobIndex = 2; + const int biasBlobIndex = weightsBlobIndex + hasWeights; + + if( hasWeights ) + { + CV_Assert((size_t)weightsBlobIndex < blobs.size()); + const Mat& w = blobs[weightsBlobIndex]; + CV_Assert(w.isContinuous() && w.type() == CV_32F && w.total() == (size_t)n); + } + + if( hasBias ) + { + CV_Assert((size_t)biasBlobIndex < blobs.size()); + const Mat& b = blobs[weightsBlobIndex]; + CV_Assert(b.isContinuous() && b.type() == CV_32F && b.total() == (size_t)n); + } + + const float* meanData = blobs[0].ptr(); + const float* stdData = blobs[1].ptr(); + const float* weightsData = hasWeights ? blobs[weightsBlobIndex].ptr() : 0; + const float* biasData = hasBias ? blobs[biasBlobIndex].ptr() : 0; + + weights_.create(1, (int)n, CV_32F); + bias_.create(1, (int)n, CV_32F); + + float* dstWeightsData = weights_.ptr(); + float* dstBiasData = bias_.ptr(); + + for (size_t i = 0; i < n; ++i) + { + float w = (hasWeights ? weightsData[i] : 1.0f) / sqrt(stdData[i] * varMeanScale + epsilon); + dstWeightsData[i] = w; + dstBiasData[i] = (hasBias ? biasData[i] : 0.0f) - w * meanData[i] * varMeanScale; + } + } + + void getScaleShift(Mat& scale, Mat& shift) const + { + scale = weights_; + shift = bias_; + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals); + return true; + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide(); + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + CV_Assert(blobs.size() >= 2); + CV_Assert(inputs.size() == 1); + + Mat &inpBlob = *inputs[0]; + int rows = inpBlob.size[2]; + int cols = inpBlob.size[3]; + + for (size_t ii = 0; ii < outputs.size(); ii++) + { + Mat &outBlob = outputs[ii]; + + for(int num = 0; num < outBlob.size[0]; num++) + { + for (int n = 0; n < outBlob.size[1]; n++) + { + float w = weights_.at(n); + float b = bias_.at(n); + Mat inpBlobPlane(rows, cols, CV_32F, inpBlob.ptr(num, n)); + Mat outBlobPlane(rows, cols, CV_32F, outBlob.ptr(num, n)); + inpBlobPlane.convertTo(outBlobPlane, CV_32F, w, b); + } + } + } + } + + virtual Ptr tryAttach(const Ptr& node) + { + switch (node->backendId) + { + case DNN_BACKEND_HALIDE: + { +#ifdef HAVE_HALIDE + auto base = node.dynamicCast(); + Halide::Func& input = base->funcs.back(); + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = attachHalide(input(x, y, c, n)); + return Ptr(new HalideBackendNode(base, top)); +#endif // HAVE_HALIDE + break; + } + } + return Ptr(); + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer input = halideBuffer(inputs[0]); + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = attachHalide(input(x, y, c, n)); + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + +#ifdef HAVE_HALIDE + // attachHalide can work both with Halide::Buffer and Halide::Func. In the + // second case it will be a fusion. + Halide::Func attachHalide(const Halide::Expr& input) + { + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Var x("x"), y("y"), c("c"), n("n"); + + const int numChannels = weights_.total(); + auto weights = wrapToHalideBuffer(weights_, {numChannels}); + auto bias = wrapToHalideBuffer(bias_, {numChannels}); + top(x, y, c, n) = input * weights(c) + bias(c); + return top; + } +#endif // HAVE_HALIDE + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + + int64 flops = 0; + for(int i = 0; i < inputs.size(); i++) + { + flops += 3*total(inputs[i]); + } + return flops; + } +}; + +Ptr BatchNormLayer::create(const LayerParams& params) +{ + return Ptr(new BatchNormLayerImpl(params)); +} + +} // namespace dnn +} // namespace cv diff --git a/modules/dnn/src/layers/blank_layer.cpp b/modules/dnn/src/layers/blank_layer.cpp new file mode 100644 index 0000000000..f90f238c90 --- /dev/null +++ b/modules/dnn/src/layers/blank_layer.cpp @@ -0,0 +1,78 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ +#include "../precomp.hpp" + +namespace cv +{ +namespace dnn +{ +class BlankLayerImpl : public BlankLayer +{ +public: + BlankLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals); + return true; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for (int i = 0, n = outputs.size(); i < n; ++i) + if (outputs[i].data != inputs[i]->data) + inputs[i]->copyTo(outputs[i]); + } +}; + +Ptr BlankLayer::create(const LayerParams& params) +{ + return Ptr(new BlankLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/concat_layer.cpp b/modules/dnn/src/layers/concat_layer.cpp new file mode 100644 index 0000000000..26fb64c15a --- /dev/null +++ b/modules/dnn/src/layers/concat_layer.cpp @@ -0,0 +1,141 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" + +namespace cv +{ +namespace dnn +{ + +class ConcatLayerImpl : public ConcatLayer +{ +public: + ConcatLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + axis = params.get("axis", 1); + } + + virtual bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() > 0); + outputs.clear(); + outputs.push_back(inputs[0]); + int cAxis = clamp(axis, inputs[0]); + + int axisSum = 0; + for (size_t i = 0; i < inputs.size(); i++) + { + MatShape curShape = inputs[i]; + + CV_Assert(curShape.size() == outputs.back().size()); + for (int curAxis = 0; curAxis < outputs.back().size(); curAxis++) + { + if (curAxis != cAxis && outputs.back()[curAxis] != curShape[curAxis]) + CV_Error(Error::StsBadSize, "Inconsitent shape for ConcatLayer"); + } + + axisSum += curShape[cAxis]; + } + + outputs.back()[cAxis] = axisSum; + + return false; + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide() && axis == 1; // By channels + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + int cAxis = clamp(axis, inputs[0]->dims); + Mat& outMat = outputs[0]; + std::vector ranges(outputs[0].dims, Range::all()); + + ranges[cAxis].start = 0; + for (size_t i = 0; i < inputs.size(); i++) + { + ranges[cAxis].end = ranges[cAxis].start + inputs[i]->size[cAxis]; + inputs[i]->copyTo(outMat(&ranges[0])); + ranges[cAxis].start = ranges[cAxis].end; + } + } + + virtual Ptr initHalide(const std::vector > &input) + { +#ifdef HAVE_HALIDE + std::vector > inputBuffers = halideBuffers(input); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + int offset = inputBuffers[0].channels(); + Halide::Expr topExpr = select(c < offset, + inputBuffers[0](x, y, c, n), + inputBuffers[1](x, y, c - offset, n)); + for (int i = 2; i < input.size(); ++i) + { + offset += inputBuffers[i - 1].channels(); + topExpr = select(c < offset, topExpr, + inputBuffers[i](x, y, c - offset, n)); + } + top(x, y, c, n) = topExpr; + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } +}; + +Ptr ConcatLayer::create(const LayerParams& params) +{ + return Ptr(new ConcatLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/convolution_layer.cpp b/modules/dnn/src/layers/convolution_layer.cpp new file mode 100644 index 0000000000..9dac3e7072 --- /dev/null +++ b/modules/dnn/src/layers/convolution_layer.cpp @@ -0,0 +1,1145 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" +#include "opencv2/core/hal/hal.hpp" +#include "opencv2/core/hal/intrin.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class BaseConvolutionLayerImpl : public ConvolutionLayer +{ +public: + BaseConvolutionLayerImpl() {} + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide(); + } + + void finalize(const std::vector &inputs, std::vector &outputs) + { + CV_Assert(inputs.size() > 0); + + CV_Assert(blobs.size() >= 1 && blobs.size() <= 2); + CV_Assert(blobs[0].dims == 4 && blobs[0].size[3] == kernel.width && blobs[0].size[2] == kernel.height); + + const Mat &input = *inputs[0]; + CV_Assert(input.dims == 4 && (input.type() == CV_32F || input.type() == CV_64F)); + for (size_t i = 0; i < inputs.size(); i++) + { + CV_Assert(inputs[i]->type() == input.type()); + CV_Assert(inputs[i]->dims == 4 && inputs[i]->size[1] == input.size[1]); + CV_Assert(inputs[i]->size[2] == input.size[2] && inputs[i]->size[3] == input.size[3]); + } + + Size outSize = Size(outputs[0].size[3], outputs[0].size[2]); + getConvPoolPaddings(Size(input.size[3], input.size[2]), outSize, + kernel, stride, padMode, pad); + } + + bool hasBias() const + { + return blobs.size() >= 2; + } + + virtual MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const = 0; + bool is1x1() const + { + return (kernel.height == 1 && kernel.width == 1) && + (stride.height == 1 && stride.width == 1) && + (dilation.height == 1 && dilation.width == 1); + } + bool setActivation(const Ptr& ) { return false; } + bool setBatchNorm(const Ptr& ) { return false; } + + virtual void applyHalideScheduler(Ptr& node, + const std::vector &inputs, + const std::vector &outputs, + int targetId) const + { +#ifdef HAVE_HALIDE + if (targetId != DNN_TARGET_CPU) + { + Layer::applyHalideScheduler(node, inputs, outputs, targetId); + return; + } + Halide::Var x("x"), y("y"), c("c"), n("n"), tile("tile"), yi("yi"), yo("yo"), co("co"), ci("ci"); + Halide::Func& top = node.dynamicCast()->funcs[1]; + Halide::Func& padded_input = node.dynamicCast()->funcs[0]; + + int outW, outH, outC, outN; + getCanonicalSize(outputs[0].size, &outW, &outH, &outC, &outN); + + if (outW == 1 || outH <= 2) + return; + + if (is1x1() || outC <= 16) + top.reorder(x, c, y) + .split(y, yo, yi, 2) + .fuse(yo, n, tile) + .parallel(tile) + .unroll(yi) + .vectorize(x, outW >= 16 ? 16 : outW); + else + top.reorder(x, c, y) + .split(y, yo, yi, 2) + .split(c, co, ci, 16) + .fuse(yo, co, tile).fuse(n, tile, tile) + .parallel(tile) + .unroll(yi) + .vectorize(x, outW >= 16 ? 16 : outW); + padded_input.compute_at(top, yi); +#endif // HAVE_HALIDE + } +}; + +//TODO: simultaneously convolution and bias addition for cache optimization +class ConvolutionLayerImpl : public BaseConvolutionLayerImpl +{ +public: + enum { VEC_ALIGN = 8, DFT_TYPE = CV_32F }; + Mat weightsMat; + std::vector biasvec; + std::vector reluslope; + Ptr activ; + Ptr bnorm; + + MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const + { + Size out(outShape[3], outShape[2]); + int inpGroupCn = blobs[0].size[1]; + int ksize = inpGroupCn * kernel.height * kernel.width; + return shape(out.area(), ksize); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(blobs.size() != 0); + CV_Assert(!hasBias() || blobs[1].total() == (size_t)blobs[0].size[0]); + CV_Assert(inputs.size() == (size_t)1); + + internals.clear(); + + int inpCn = inputs[0][1]; + int inpH = inputs[0][2]; + int inpW = inputs[0][3]; + + int outCn = blobs[0].size[0]; + Size out; + + if (padMode.empty()) + { + out.height = (inpH + 2 * pad.height - (dilation.height * (kernel.height - 1) + 1)) / stride.height + 1; + out.width = (inpW + 2 * pad.width - (dilation.width * (kernel.width - 1) + 1)) / stride.width + 1; + } + else + { + getConvPoolOutParams(Size(inpH, inpW), kernel, stride, padMode, out); + } + + int ngroups = inpCn / blobs[0].size[1]; + CV_Assert(inpCn % ngroups == 0 && outCn % ngroups == 0); + + int dims[] = {inputs[0][0], outCn, out.height, out.width}; + outputs.resize(inputs.size(), shape(dims)); + + return false; + } + + bool setActivation(const Ptr& layer) { activ = layer; return true; } + bool setBatchNorm(const Ptr& layer ) + { + bnorm = layer; + // we will need to re-compute the weights with the batch + // norm coefficients taken into account + weightsMat.release(); + return true; + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + + const int inpCn = inputBuffer.channels(); + const int outCn = blobs[0].size[0]; + const int inpGroupCn = blobs[0].size[1]; + const int group = inpCn / inpGroupCn; + const int outGroupCn = outCn / group; + + Halide::Buffer weights = wrapToHalideBuffer(blobs[0]); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Func padded_input(name + "_constant_exterior"); + if (pad.width || pad.height) + { + Halide::Func bounded = + Halide::BoundaryConditions::constant_exterior(inputBuffer, 0); + padded_input(x, y, c, n) = bounded(x, y, c, n); + } + else + { + padded_input(x, y, c, n) = inputBuffer(x, y, c, n); + } + + Halide::RDom r(0, kernel.width, 0, kernel.height, 0, inpGroupCn); + + Halide::Expr kc = r.z; + if (group > 1) + { + int outCnBound = outGroupCn; + int inpChBound = inpGroupCn; + Halide::Expr shift = select(c < outCnBound, 0, inpChBound); + for (int i = 2; i < group; ++i) + { + outCnBound += outGroupCn; + inpChBound += inpGroupCn; + shift = select(c < outCnBound, shift, inpChBound); + } + kc += shift; + } + + Halide::Expr kx = x * stride.width - pad.width + r.x * dilation.width; + Halide::Expr ky = y * stride.height - pad.height + r.y * dilation.height; + Halide::Expr topExpr = sum(padded_input(kx, ky, kc, n) * + weights(r.x, r.y, r.z, c)); + if (hasBias()) + { + Halide::Buffer bias = wrapToHalideBuffer(blobs[1], {outCn}); + topExpr += bias(c); + } + top(x, y, c, n) = topExpr; + Ptr pp(new HalideBackendNode({ padded_input, top })); + return Ptr(new HalideBackendNode({ padded_input, top })); +#endif // HAVE_HALIDE + return Ptr(); + } + + class ParallelConv : public cv::ParallelLoopBody + { + public: + enum { BLK_SIZE = 32, BLK_SIZE_CN = 64 }; + + const Mat* input_; + const Mat* weights_; + Mat* output_; + int outShape[4]; + Size kernel_, pad_, stride_, dilation_; + int ngroups_, nstripes_; + std::vector ofstab_; + const std::vector* biasvec_; + const std::vector* reluslope_; + const ActivationLayer* activ_; + bool is1x1_; + bool useAVX2; + + ParallelConv() {} + + static void run( const Mat& input, Mat& output, const Mat& weights, + const std::vector& biasvec, + const std::vector& reluslope, + Size kernel, Size pad, Size stride, Size dilation, + int ngroups, int nstripes, const ActivationLayer* activ ) + { + CV_Assert( input.dims == 4 && output.dims == 4 && + input.size[0] == output.size[0] && + weights.rows == output.size[1] && + weights.cols == (input.size[1]/ngroups)*kernel.width*kernel.height && + input.type() == output.type() && + input.type() == weights.type() && + input.type() == CV_32F && + input.isContinuous() && + output.isContinuous() && + biasvec.size() == (size_t)output.size[1]+2); + ParallelConv p; + + p.input_ = &input; + p.weights_ = &weights; + p.output_ = &output; + for( int i = 0; i < 4; i++ ) p.outShape[i] = output.size[i]; + p.outShape[1] /= ngroups; + p.kernel_ = kernel; p.pad_ = pad; p.stride_ = stride; p.dilation_ = dilation; + p.ngroups_ = ngroups; + p.nstripes_ = nstripes; + + int inpCnAll = input.size[1], width = input.size[3], height = input.size[2]; + int inpCn = inpCnAll / ngroups; + p.is1x1_ = kernel == Size(0,0) && pad == Size(0, 0); + p.useAVX2 = checkHardwareSupport(CPU_AVX2); + + int ncn = std::min(inpCn, (int)BLK_SIZE_CN); + p.ofstab_.resize(kernel.width*kernel.height*ncn); + int* ofstab = &p.ofstab_[0]; + + for( int k = 0; k < ncn; k++ ) + for( int k_r = 0; k_r < kernel.height; k_r++ ) + for( int k_c = 0; k_c < kernel.width; k_c++ ) + ofstab[(k*kernel.height + k_r)*kernel.width + k_c] = + (k*height + k_r*dilation.height)*width + k_c*dilation.width; + + p.biasvec_ = &biasvec; + p.reluslope_ = &reluslope; + p.activ_ = p.reluslope_->empty() ? activ : 0; + + parallel_for_(Range(0, nstripes), p, nstripes); + } + + virtual void operator ()(const Range &r0) const + { + const int valign = ConvolutionLayerImpl::VEC_ALIGN; + int ngroups = ngroups_, batchSize = input_->size[0]*ngroups; + int outW = output_->size[3], outH = output_->size[2], outCn = output_->size[1]/ngroups; + int width = input_->size[3], height = input_->size[2], inpCn = input_->size[1]/ngroups; + int nstripes = nstripes_; + int kernel_w = kernel_.width, kernel_h = kernel_.height; + int pad_w = pad_.width, pad_h = pad_.height; + int stride_w = stride_.width, stride_h = stride_.height; + int dilation_w = dilation_.width, dilation_h = dilation_.height; + int karea = kernel_w*kernel_h; + int i, j, k; + size_t inpPlaneSize = width*height; + size_t outPlaneSize = outW*outH; + bool is1x1 = is1x1_; + + int stripesPerSample; + size_t stripeSize; + Range r = r0; + + if( nstripes >= batchSize*2 ) + { + stripesPerSample = nstripes/batchSize; + stripeSize = alignSize((outPlaneSize + stripesPerSample - 1)/stripesPerSample, valign); + stripeSize = std::min(stripeSize, outPlaneSize); + } + else + { + stripesPerSample = 1; + int samplesPerStripe = std::max((batchSize + nstripes - 1)/nstripes, 1); + r.start *= samplesPerStripe; + r.end *= samplesPerStripe; + nstripes *= samplesPerStripe; + stripeSize = outPlaneSize; + } + + const float* data_inp0_ = input_->ptr(); + const int* ofstab = &ofstab_[0]; + const float* wptr_orig_ = weights_->ptr(); + size_t wstep = weights_->step1(); + const float* biasptr_ = &biasvec_->at(0); + const float* reluptr_ = reluslope_->empty() ? 0 : &reluslope_->at(0); + float* data_out0_ = output_->ptr(); + size_t rowbufsz = (size_t)karea*BLK_SIZE_CN*BLK_SIZE; + AutoBuffer rowbuf0_(rowbufsz + valign); + float* rowbuf0 = alignPtr((float*)rowbuf0_, (int)(valign*sizeof(float))); + + // we clear the buffer once; ultimately, it lets us to avoid + // tail processing after running the unrolled/vectorized loop. + // the main idea is to make sure that the tail (a.k.a. padding) of each row + // (i.e. the elements with indices between vsz=karea*ncn and vsz_a) + // does not contain NaNs or Infs. Because the padding in the weights + // matrix is explicitly initialized with 0's, we handle all other + // cases nicely, i.e. we can skip expliciting re-initialization + // of the padding - we just retain elements from the previous iteration + // of the loop over channels (cn0). + memset(rowbuf0, 0, rowbufsz*sizeof(rowbuf0[0]) ); + + for( int stripe = r.start; stripe < r.end; stripe++ ) + { + int subsampleIdx = stripe/stripesPerSample; + if( subsampleIdx >= batchSize ) + break; + int stripeStart = (int)((stripe - subsampleIdx*stripesPerSample)*stripeSize); + int stripeEnd = (int)std::min(stripeStart + stripeSize, outPlaneSize); + const float* data_inp0 = data_inp0_ + subsampleIdx*inpPlaneSize*inpCn; + float* data_out0 = data_out0_ + subsampleIdx*outPlaneSize*outCn; + int startOutCn = (subsampleIdx % ngroups)*outCn; + const float* wptr_orig = wptr_orig_ + wstep*startOutCn; + const float* biasptr = biasptr_ + startOutCn; + + for( int cn0 = 0; cn0 < inpCn; cn0 += BLK_SIZE_CN ) + { + int cn1 = std::min(cn0 + BLK_SIZE_CN, inpCn); + int ncn = cn1 - cn0, vsz = karea*ncn; + int vsz_a = (int)alignSize(vsz, valign); + const float* wptr = wptr_orig + cn0*karea; + // we apply [Channels][P]ReLU (if any) during the final pass only. + const float* relu = cn1 == inpCn && reluptr_ ? reluptr_ + startOutCn : 0; + + for( int ofs0 = stripeStart; ofs0 < stripeEnd; ofs0 += BLK_SIZE ) + { + int ofs, ofs1 = std::min(ofs0 + BLK_SIZE, stripeEnd); + + // do im2row for a part of input tensor + if( is1x1 ) + { + for( ofs = ofs0; ofs < ofs1; ofs++ ) + { + int out_i = ofs / outW; + int out_j = ofs - out_i * outW; + float* rowbuf = rowbuf0 + (ofs - ofs0)*vsz_a; + + int in_i = out_i * stride_h - pad_h; + int in_j = out_j * stride_w - pad_w; + const float* imgptr = data_inp0 + (cn0*height + in_i)*width + in_j; + + for( k = 0; k < vsz; k++ ) + rowbuf[k] = imgptr[k*inpPlaneSize]; + } + } + else + { + for( ofs = ofs0; ofs < ofs1; ofs++ ) + { + int out_i = ofs / outW; + int out_j = ofs - out_i * outW; + float* rowbuf = rowbuf0 + (ofs - ofs0)*vsz_a; + + int in_i = out_i * stride_h - pad_h; + int in_j = out_j * stride_w - pad_w; + const float* imgptr = data_inp0 + (cn0*height + in_i)*width + in_j; + + // this condition should be true for most of the tensor elements, i.e. + // most of the time the kernel aperture is inside the tensor X-Y plane. + if( 0 <= in_i && in_i < height - (kernel_h-1)*dilation_h && + 0 <= in_j && in_j < width - (kernel_w-1)*dilation_w ) + { + for( k = 0; k < vsz; k++ ) + rowbuf[k] = imgptr[ofstab[k]]; + } + else + { + int i0 = std::max(0, (-in_i + dilation_h-1)/dilation_h); + int i1 = std::min(kernel_h, (height - in_i + dilation_h-1)/dilation_h); + int j0 = std::max(0, (-in_j + dilation_w-1)/dilation_w); + int j1 = std::min(kernel_w, (width - in_j + dilation_w-1)/dilation_w); + + // here some non-continous sub-row of the row will not be + // filled from the tensor; we need to make sure that the uncovered + // elements are explicitly set to 0's. the easiest way is to + // set all the elements to 0's before the loop. + memset(rowbuf, 0, vsz*sizeof(rowbuf[0])); + for( k = 0; k < ncn; k++, imgptr += width*height ) + { + for( i = i0; i < i1; i++ ) + { + for( j = j0; j < j1; j++ ) + { + int imgofs = i*(dilation_h*width) + j*dilation_w; + rowbuf[(k*kernel_h + i)*kernel_w + j] = imgptr[imgofs]; + } + } + } + } + } + } + + // now compute dot product of the weights + // and im2row-transformed part of the tensor + int bsz = ofs1 - ofs0; + #if CV_DNN_TRY_AVX2 + if(useAVX2) + fastConv_avx2(wptr, wstep, biasptr, rowbuf0, data_out0 + ofs0, + outShape, bsz, vsz, vsz_a, relu, cn0 == 0); + else + #endif + for( int i = 0; i < outCn; i += 2 ) + { + const float* wptr0 = wptr + i*wstep; + const float* wptr1 = wptr0 + wstep; + float* outptr0 = data_out0 + ofs0 + i*outPlaneSize; + float* outptr1 = outptr0 + outPlaneSize; + float bias0 = biasptr[i], bias1 = biasptr[i+1]; + float r0 = 1.f, r1 = 1.f; + + if( i+1 >= outCn ) + { + wptr1 = wptr0; + outptr1 = outptr0; + bias1 = bias0; + } + + if( relu ) + { + r0 = relu[i]; + r1 = relu[i+1]; + } + + int j = 0; + #if CV_SIMD128 + v_float32x4 vr0 = v_setall_f32(r0), vr1 = v_setall_f32(r1), z = v_setzero_f32(); + + for( ; j <= bsz - 4; j += 4 ) + { + const float* rptr = rowbuf0 + j*vsz_a; + v_float32x4 s0, s1; + + if( cn0 == 0 ) + { + s0 = v_setall_f32(bias0); + s1 = v_setall_f32(bias1); + } + else + { + s0 = v_load(outptr0 + j); + s1 = v_load(outptr1 + j); + } + + v_float32x4 vs00 = v_setzero_f32(), vs01 = v_setzero_f32(), + vs02 = v_setzero_f32(), vs03 = v_setzero_f32(), + vs10 = v_setzero_f32(), vs11 = v_setzero_f32(), + vs12 = v_setzero_f32(), vs13 = v_setzero_f32(); + for( k = 0; k < vsz; k += 4, rptr += 4 ) + { + v_float32x4 w0 = v_load_aligned(wptr0 + k), w1 = v_load_aligned(wptr1 + k); + v_float32x4 r0 = v_load_aligned(rptr), r1 = v_load_aligned(rptr + vsz_a), + r2 = v_load_aligned(rptr + vsz_a*2), r3 = v_load_aligned(rptr + vsz_a*3); + + vs00 += w0*r0; + vs01 += w0*r1; + vs02 += w0*r2; + vs03 += w0*r3; + + vs10 += w1*r0; + vs11 += w1*r1; + vs12 += w1*r2; + vs13 += w1*r3; + } + s0 += v_reduce_sum4(vs00, vs01, vs02, vs03); + s1 += v_reduce_sum4(vs10, vs11, vs12, vs13); + if( relu ) + { + s0 = v_select(s0 > z, s0, s0*vr0); + s1 = v_select(s1 > z, s1, s1*vr1); + } + + v_store(outptr0 + j, s0); + v_store(outptr1 + j, s1); + } + #endif + for( ; j < bsz; j++ ) + { + const float* rptr = rowbuf0 + j*vsz_a; + float s00, s10; + + if( cn0 == 0 ) + { + s00 = bias0; + s10 = bias1; + } + else + { + s00 = outptr0[j]; + s10 = outptr1[j]; + } + + for( k = 0; k < vsz; k++ ) + { + float r0 = rptr[k]; + s00 += wptr0[k]*r0; + s10 += wptr1[k]*r0; + } + if( relu ) + { + s00 = s00 > 0.f ? s00 : s00*r0; + s10 = s10 > 0.f ? s10 : s10*r1; + } + + outptr0[j] = s00; + outptr1[j] = s10; + } + } + } + } + + if( activ_ ) + activ_->forwardSlice(data_out0 + stripeStart, data_out0 + stripeStart, + (int)(stripeEnd - stripeStart), + outPlaneSize, startOutCn, startOutCn + outCn); + } + } + }; + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + /*printf("conv %s: input (%d x %d x %d x %d), kernel (%d x %d), pad (%d x %d), stride (%d x %d), dilation (%d x %d)\n", + name.c_str(), inputs[0]->size[0], inputs[0]->size[1], inputs[0]->size[2], inputs[0]->size[3], + kernel.width, kernel.height, pad.width, pad.height, + stride.width, stride.height, dilation.width, dilation.height);*/ + CV_Assert(inputs.size() == (size_t)1 && inputs[0]->size[1] % blobs[0].size[1] == 0); + int ngroups = inputs[0]->size[1]/blobs[0].size[1]; + CV_Assert(outputs[0].size[1] % ngroups == 0); + + int k, outCn = blobs[0].size[0]; + + if( weightsMat.empty() ) + { + // prepare weightsMat where each row is aligned and has enough zero padding on the right to + // use vectorized (i.e. with intrinsics) loops without tail processing + Mat wm = blobs[0].reshape(1, outCn).clone(); + if( wm.step1() % VEC_ALIGN != 0 ) + { + int newcols = (int)alignSize(wm.step1(), VEC_ALIGN); + Mat wm_buffer = Mat(outCn, newcols, wm.type()); + Mat wm_padding = wm_buffer.colRange(wm.cols, newcols); + wm_padding.setTo(Scalar::all(0.)); + Mat wm_aligned = wm_buffer.colRange(0, wm.cols); + wm.copyTo(wm_aligned); + wm = wm_aligned; + } + weightsMat = wm; + + Mat biasMat = hasBias() ? blobs[1].reshape(1, outCn) : Mat(); + biasvec.resize(outCn+2); + if( biasMat.empty() ) + { + for( k = 0; k < outCn; k++ ) + biasvec[k] = 0.f; + } + else + { + for( k = 0; k < outCn; k++ ) + biasvec[k] = biasMat.at(k); + } + + if( !bnorm.empty() ) + { + Mat scale, shift; + bnorm->getScaleShift(scale, shift); + + CV_Assert( scale.isContinuous() && shift.isContinuous() && + scale.type() == CV_32F && shift.type() == CV_32F && + scale.total() == (size_t)outCn && + shift.total() == (size_t)outCn ); + + for( int i = 0; i < outCn; i++ ) + { + float s = scale.at(i); + float delta = shift.at(i); + float* w_i = weightsMat.ptr(i); + int j, wcols = weightsMat.cols; + + for( j = 0; j < wcols; j++ ) + w_i[j] *= s; + + biasvec[i] = biasvec[i]*s + delta; + } + } + biasvec[outCn] = biasvec[outCn+1] = biasvec[outCn-1]; + } + + if( activ ) + { + Ptr activ_relu = activ.dynamicCast(); + if( !activ_relu.empty() ) + reluslope.assign(outCn+2, activ_relu->negativeSlope); + + Ptr activ_chprelu = activ.dynamicCast(); + if( !activ_chprelu.empty() ) + { + const Mat& m = activ_chprelu->blobs[0]; + CV_Assert(m.isContinuous() && m.type() == CV_32F && (int)m.total() == outCn); + const float* mdata = m.ptr(); + reluslope.resize(outCn+2); + std::copy(mdata, mdata + outCn, reluslope.begin()); + reluslope[outCn] = reluslope[outCn+1] = reluslope[outCn-1]; + } + } + + int nstripes = std::max(getNumThreads(), 1); + + ParallelConv::run(*inputs[0], outputs[0], weightsMat, biasvec, reluslope, + kernel, pad, stride, dilation, ngroups, nstripes, activ.get()); + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + CV_Assert(inputs.size() == outputs.size()); + + int64 flops = 0; + for (int i = 0; i < inputs.size(); i++) + { + flops += total(outputs[i])*(2*kernel.area()*inputs[i][1] + 1); + } + + return flops; + } +}; + +class DeConvolutionLayerImpl : public BaseConvolutionLayerImpl +{ +public: + Mat weightsMat, biasesMat; + + MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const + { + int inpCn = inpShape[1]; + int inpH = inpShape[2]; + int inpW = inpShape[3]; + int outCn = outShape[1]; + int ngroups = inpCn / blobs[0].size[1]; + int outGroupCn = outCn / ngroups; + int ksize = outGroupCn * kernel.height * kernel.width; + return shape(ksize, inpH * inpW); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(!hasBias() || blobs[1].total() == (size_t)blobs[0].size[0]); + CV_Assert(inputs.size() != 0); + + int inpCn = inputs[0][1]; + int inpH = inputs[0][2]; + int inpW = inputs[0][3]; + + int outH = stride.height * (inpH - 1) + kernel.height - 2 * pad.height + adjustPad.height; + int outW = stride.width * (inpW - 1) + kernel.width - 2 * pad.width + adjustPad.width; + int outCn = blobs[0].size[0]; + + int ngroups = inpCn / blobs[0].size[1]; + + CV_Assert(inpCn % ngroups == 0 && outCn % ngroups == 0); + CV_Assert(blobs[0].size[0] == outCn && blobs[0].size[1] == inpCn / ngroups); + + int dims[] = {inputs[0][0], outCn, outH, outW}; + outputs.resize(inputs.size(), shape(dims)); + + internals.push_back(MatShape()); + if (!is1x1()) + internals[0] = computeColRowShape(inputs[0], outputs[0]); + + if (hasBias()) + internals.push_back(shape(1, outH*outW)); + + return false; + } + + class MatMulInvoker : public ParallelLoopBody + { + public: + MatMulInvoker(const Mat& a, const Mat& b, Mat& c, int nstripes) + { + a_ = &a; + b_ = &b; + c_ = &c; + nstripes_ = nstripes; + useAVX2 = checkHardwareSupport(CPU_AVX2); + } + + void operator()(const Range& range_) const + { + int stripeSize = (int)alignSize((b_->cols + nstripes_ - 1)/nstripes_, 16); + Range range(range_.start*stripeSize, std::min(range_.end*stripeSize, b_->cols)); + int mmax = a_->rows; + int nmax = range.end - range.start; + int kmax = a_->cols; + int m, n, k; + const float* aptr = a_->ptr(); + const float* bptr = b_->ptr() + range.start; + float* cptr = c_->ptr() + range.start; + size_t astep = a_->step1(); + size_t bstep = b_->step1(); + size_t cstep = c_->step1(); + + #if CV_DNN_TRY_AVX2 + if( useAVX2 ) + fastGEMM_avx2( aptr, astep, bptr, bstep, cptr, cstep, mmax, kmax, nmax ); + else + #endif + for( m = 0; m < mmax; m += 2 ) + { + float* dst0 = cptr + cstep*m; + float* dst1 = cptr + cstep*std::min(m+1, mmax-1); + const float* aptr0 = aptr + astep*m; + const float* aptr1 = aptr + astep*std::min(m+1, mmax-1); + + for( n = 0; n < nmax; n++ ) + { + dst0[n] = 0.f; + dst1[n] = 0.f; + } + + for( k = 0; k < kmax; k += 4 ) + { + float alpha00 = aptr0[k]; + float alpha01 = aptr1[k]; + float alpha10 = 0.f, alpha11 = 0.f; + float alpha20 = 0.f, alpha21 = 0.f; + float alpha30 = 0.f, alpha31 = 0.f; + const float* bptr0 = bptr + k*bstep; + const float* bptr1 = bptr0; + const float* bptr2 = bptr0; + const float* bptr3 = bptr0; + + if( k+1 < kmax ) + { + alpha10 = aptr0[k+1]; + alpha11 = aptr1[k+1]; + bptr1 = bptr0 + bstep; + if( k+2 < kmax ) + { + alpha20 = aptr0[k+2]; + alpha21 = aptr1[k+2]; + bptr2 = bptr1 + bstep; + if( k+3 < kmax ) + { + alpha30 = aptr0[k+3]; + alpha31 = aptr1[k+3]; + bptr3 = bptr2 + bstep; + } + } + } + n = 0; + + #if CV_SIMD128 + v_float32x4 a00 = v_setall_f32(alpha00); + v_float32x4 a01 = v_setall_f32(alpha01); + v_float32x4 a10 = v_setall_f32(alpha10); + v_float32x4 a11 = v_setall_f32(alpha11); + v_float32x4 a20 = v_setall_f32(alpha20); + v_float32x4 a21 = v_setall_f32(alpha21); + v_float32x4 a30 = v_setall_f32(alpha30); + v_float32x4 a31 = v_setall_f32(alpha31); + + for( ; n <= nmax - 4; n += 4 ) + { + v_float32x4 b0 = v_load(bptr0 + n); + v_float32x4 b1 = v_load(bptr1 + n); + v_float32x4 b2 = v_load(bptr2 + n); + v_float32x4 b3 = v_load(bptr3 + n); + v_float32x4 d0 = v_load(dst0 + n); + v_float32x4 d1 = v_load(dst1 + n); + d0 += b0*a00; + d1 += b0*a01; + d0 += b1*a10; + d1 += b1*a11; + d0 += b2*a20; + d1 += b2*a21; + d0 += b3*a30; + d1 += b3*a31; + v_store(dst0 + n, d0); + v_store(dst1 + n, d1); + } + #endif + + for( ; n < nmax; n++ ) + { + float b0 = bptr0[n], b1 = bptr1[n]; + float b2 = bptr2[n], b3 = bptr3[n]; + float d0 = dst0[n] + alpha00*b0 + alpha10*b1 + alpha20*b2 + alpha30*b3; + float d1 = dst1[n] + alpha01*b0 + alpha11*b1 + alpha21*b2 + alpha31*b3; + dst0[n] = d0; + dst1[n] = d1; + } + } + } + } + + const Mat *a_, *b_; + Mat* c_; + int nstripes_; + bool useAVX2; + }; + + class Col2ImInvoker : public cv::ParallelLoopBody + { + public: + const float* data_col; + const float* biasvec; + int channels, height, width; + int kernel_h, kernel_w; + int pad_h, pad_w; + int stride_h, stride_w; + float* data_im; + int height_col, width_col; + int nstripes; + bool is1x1; + + Col2ImInvoker() {} + + static void run(const float* data_col, + int channels, int height, int width, + int kernel_h, int kernel_w, + int pad_h, int pad_w, + int stride_h, int stride_w, + float* data_im, + const float* biasvec, + bool is1x1) + { + const int nstripes = getNumThreads(); + + Col2ImInvoker t; + t.data_col = data_col; + t.data_im = data_im; + t.channels = channels; t.height = height; t.width = width; + t.kernel_h = kernel_h; t.kernel_w = kernel_w; + t.pad_h = pad_h; t.pad_w = pad_w; + t.stride_h = stride_h; t.stride_w = stride_w; + t.height_col = (height + 2 * pad_h - kernel_h) / stride_h + 1; + t.width_col = (width + 2 * pad_w - kernel_w) / stride_w + 1; + t.nstripes = nstripes; + t.is1x1 = is1x1; + t.biasvec = biasvec; + + parallel_for_(Range(0, nstripes), t, nstripes); + } + + virtual void operator ()(const Range &r) const + { + const float* data_col_ = data_col; + float* data_im_ = data_im; + int coeff_h = (1 - stride_h * kernel_w * height_col) * width_col; + int coeff_w = (1 - stride_w * height_col * width_col); + size_t total = (size_t)channels * height * width; + size_t stripeSize = (total + nstripes - 1)/nstripes; + size_t startIndex = r.start*stripeSize; + size_t endIndex = std::min(r.end*stripeSize, total); + int w = (int)(startIndex % width + pad_w); + int h = (int)((startIndex / width) % height + pad_h); + int c = (int)(startIndex / (width * height)); + int h_col_start = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1; + int h_col_end = std::min(h / stride_h + 1, height_col); + int plane_size_col = height_col * width_col; + int offset = (c * kernel_h * kernel_w + h * kernel_w + w) * plane_size_col; + bool is1x1_ = is1x1; + const float* biasvec_ = biasvec; + + for (size_t index = startIndex; index < endIndex; index++) + { + // compute the start and end of the output + int w_col_start = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1; + int w_col_end = std::min(w / stride_w + 1, width_col); + float val; + + if( is1x1_ ) + val = data_im_[index]; + else + { + val = 0.f; + for (int h_col = h_col_start; h_col < h_col_end; ++h_col) { + for (int w_col = w_col_start; w_col < w_col_end; ++w_col) { + val += data_col_[offset + h_col * coeff_h + w_col * coeff_w]; + } + } + } + data_im_[index] = val + biasvec_[c]; + + offset += plane_size_col; + if( ++w >= width + pad_w ) + { + w = (int)((index + 1)% width + pad_w); + h = (int)(((index + 1) / width) % height + pad_h); + c = (int)((index + 1) / (width * height)); + h_col_start = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1; + h_col_end = std::min(h / stride_h + 1, height_col); + offset = (c * kernel_h * kernel_w + h * kernel_w + w) * plane_size_col; + } + } + } + }; + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + int outCn = blobs[0].size[0]; + int inpCn = inputs[0]->size[1]; + bool is1x1flag = is1x1(); + int nstripes = getNumThreads(); + + if( weightsMat.empty() ) + { + transpose(blobs[0].reshape(1, inpCn), weightsMat); + biasesMat = hasBias() ? blobs[1].reshape(1, outCn) : Mat::zeros(outCn, 1, CV_32F); + } + + for (size_t ii = 0; ii < outputs.size(); ii++) + { + int ngroups = inpCn / blobs[0].size[1]; + int inpGroupCn = blobs[0].size[1]; + int outGroupCn = outCn / ngroups; + const Mat& inp = *inputs[ii]; + Mat& out = outputs[ii]; + int numImg = inp.size[0]; + int outH = out.size[2], outW = out.size[3]; + + Mat convBlob = inputs[ii]->reshape(1, numImg*inpCn); + Mat decnBlob = out.reshape(1, numImg*outCn); + + for (int n = 0; n < numImg; n++) + { + for (int g = 0; g < ngroups; g++) + { + Mat dstMat = decnBlob.rowRange(_Range((g + n * ngroups) * outGroupCn, outGroupCn)); + Mat &colMat = is1x1flag ? dstMat : internals[0]; + + Mat convMat = convBlob.rowRange(_Range((g + n * ngroups) * inpGroupCn, inpGroupCn)); + Mat wghtMat = weightsMat.colRange(_Range(g * inpGroupCn, inpGroupCn)); + Mat curBiasMat = biasesMat.rowRange(_Range(g * outGroupCn, outGroupCn)); + + //gemm(wghtMat, convMat, 1, colMat, 0, colMat, 0); + MatMulInvoker mminvoker(wghtMat, convMat, colMat, nstripes); + parallel_for_(Range(0, nstripes), mminvoker, nstripes); + + Col2ImInvoker::run(colMat.ptr(), outGroupCn, outH, outW, + kernel.height, kernel.width, pad.height, pad.width, + stride.height, stride.width, dstMat.ptr(), + curBiasMat.ptr(), is1x1flag); + } + } + } + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + + int inW, inH, inC, inN, outC = blobs[0].size[0]; + getCanonicalSize(inputBuffer, &inW, &inH, &inC, &inN); + + if (inC / blobs[0].size[1] != 1) + CV_Error(cv::Error::StsNotImplemented, + "Halide backend for Deconvolution with group > 1 is not implemented"); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Func padded_input(name + "_constant_exterior"); + auto weights = wrapToHalideBuffer(blobs[0], {kernel.width, + kernel.height, outC, inC}); + + Halide::Func dilated_input("dilated_input"); + dilated_input(x, y, c, n) = 0.0f; + Halide::RDom r1(0, inW, 0, inH); + dilated_input(r1.x * stride.width, r1.y * stride.height, c, n) = + inputBuffer(r1.x, r1.y, c, n); + dilated_input.compute_root(); + + Halide::Func bounded = + Halide::BoundaryConditions::constant_exterior(dilated_input, 0, + 0, (inW - 1) * stride.width + 1, + 0, (inH - 1) * stride.height + 1, + 0, inC, 0, inN); + padded_input(x, y, c, n) = bounded(x, y, c, n); + + Halide::RDom r(0, kernel.width, 0, kernel.height, 0, inC); + Halide::Expr topExpr = sum( + padded_input(x + pad.width - r.x, y + pad.height - r.y, r.z, n) * + weights(r.x, r.y, c, r.z)); + if (hasBias()) + { + auto bias = wrapToHalideBuffer(blobs[1], {outC}); + topExpr += bias(c); + } + top(x, y, c, n) = topExpr; + return Ptr(new HalideBackendNode({ padded_input, top })); +#endif // HAVE_HALIDE + return Ptr(); + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + CV_Assert(inputs.size() == outputs.size()); + + float flops = 0; + int outChannels = blobs[0].size[0]; + + for (int i = 0; i < inputs.size(); i++) + { + flops += 2*outChannels*kernel.area()*total(inputs[i]); + } + + return flops; + } +}; + +//Convolution and Deconvolution +static void initConvDeconvLayerFromCaffe(Ptr l, const LayerParams ¶ms) +{ + l->setParamsFrom(params); + getConvolutionKernelParams(params, l->kernel.height, l->kernel.width, l->pad.height, + l->pad.width, l->stride.height, l->stride.width, l->dilation.height, + l->dilation.width, l->padMode); + + bool bias = params.get("bias_term", true); + int numOutput = params.get("num_output"); + int ngroups = params.get("group", 1); + + l->adjustPad.height = params.get("adj_h", 0); + l->adjustPad.width = params.get("adj_w", 0); + + CV_Assert(numOutput % ngroups == 0); + CV_Assert((bias && l->blobs.size() == 2) || (!bias && l->blobs.size() == 1)); + CV_Assert(l->adjustPad.width < l->stride.width && + l->adjustPad.height < l->stride.height); +} + +Ptr ConvolutionLayer::create(const LayerParams ¶ms) +{ + Ptr l(new ConvolutionLayerImpl); + initConvDeconvLayerFromCaffe(l, params); + return l; +} + +Ptr DeconvolutionLayer::create(const LayerParams ¶ms) +{ + Ptr l(new DeConvolutionLayerImpl); + initConvDeconvLayerFromCaffe(l, params); + + return l; +} + +} +} diff --git a/modules/dnn/src/layers/crop_layer.cpp b/modules/dnn/src/layers/crop_layer.cpp new file mode 100644 index 0000000000..5615033ccb --- /dev/null +++ b/modules/dnn/src/layers/crop_layer.cpp @@ -0,0 +1,153 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" + +namespace cv +{ +namespace dnn +{ + +class CropLayerImpl : public CropLayer +{ +public: + CropLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + startAxis = params.get("axis", 2); + const DictValue *paramOffset = params.ptr("offset"); + + if (paramOffset) + { + for (int i = 0; i < paramOffset->size(); i++) + offset.push_back(paramOffset->get(i)); + } + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() == 2); + + MatShape dstShape = inputs[0]; + int start = clamp(startAxis, dstShape); + for (int i = start; i < dstShape.size(); i++) + { + dstShape[i] = inputs[1][i]; + } + + outputs.resize(1, dstShape); + + return false; + } + + void finalize(const std::vector &inputs, std::vector &outputs) + { + CV_Assert(2 == inputs.size()); + + const Mat &inpBlob = *inputs[0]; + const Mat &inpSzBlob = *inputs[1]; + + int dims = inpBlob.dims; + int start_axis = clamp(startAxis, dims); + + std::vector offset_final(dims, 0); + if (offset.size() == 1) + { + for (int i = start_axis; i < dims; i++) + offset_final[i] = offset[0]; + } + else if (offset.size() > 1) + { + if ((int)offset.size() != dims - start_axis) + CV_Error(Error::StsBadArg, "number of offset values specified must be " + "equal to the number of dimensions following axis."); + + for (int i = start_axis; i < dims; i++) + offset_final[i] = offset[i - start_axis]; + } + + crop_ranges.resize(dims, Range::all()); + for (int i = 0; i < dims; i++) + { + if( i < start_axis ) + continue; + + if (!offset.empty()) //normal case + { + if (offset_final[i] < 0 || offset_final[i] + inpSzBlob.size[i] > inpBlob.size[i]) + CV_Error(Error::StsBadArg, "invalid crop parameters"); + + crop_ranges[i] = Range(offset_final[i], offset_final[i] + inpSzBlob.size[i]); + } + else //detect offset automatically so that cropped image is center of original one + { + if (inpSzBlob.size[i] > inpBlob.size[i]) + CV_Error(Error::StsBadArg, "invalid output blob size"); + + int cur_crop = (inpBlob.size[i] - inpSzBlob.size[i]) / 2; + crop_ranges[i] = Range(cur_crop, cur_crop + inpSzBlob.size[i]); + } + } + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + Mat &input = *inputs[0]; + Mat &output = outputs[0]; + + input(&crop_ranges[0]).copyTo(output); + } + + std::vector crop_ranges; +}; + + +Ptr CropLayer::create(const LayerParams& params) +{ + return Ptr(new CropLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/detection_output_layer.cpp b/modules/dnn/src/layers/detection_output_layer.cpp new file mode 100644 index 0000000000..463d0a093d --- /dev/null +++ b/modules/dnn/src/layers/detection_output_layer.cpp @@ -0,0 +1,798 @@ +/*M /////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include +#include +#include + +namespace cv +{ +namespace dnn +{ + +namespace util +{ + +template +std::string to_string(T value) +{ + std::ostringstream stream; + stream << value; + return stream.str(); +} + +template +void make_error(const std::string& message1, const T& message2) +{ + std::string error(message1); + error += std::string(util::to_string(message2)); + CV_Error(Error::StsBadArg, error.c_str()); +} + +template +bool SortScorePairDescend(const std::pair& pair1, + const std::pair& pair2) +{ + return pair1.first > pair2.first; +} + +} + +class DetectionOutputLayerImpl : public DetectionOutputLayer +{ +public: + unsigned _numClasses; + bool _shareLocation; + int _numLocClasses; + + int _backgroundLabelId; + + typedef caffe::PriorBoxParameter_CodeType CodeType; + CodeType _codeType; + + bool _varianceEncodedInTarget; + int _keepTopK; + float _confidenceThreshold; + + float _nmsThreshold; + int _topK; + + enum { _numAxes = 4 }; + static const std::string _layerName; + + typedef std::map > LabelBBox; + + bool getParameterDict(const LayerParams ¶ms, + const std::string ¶meterName, + DictValue& result) + { + if (!params.has(parameterName)) + { + return false; + } + + result = params.get(parameterName); + return true; + } + + template + T getParameter(const LayerParams ¶ms, + const std::string ¶meterName, + const size_t &idx=0, + const bool required=true, + const T& defaultValue=T()) + { + DictValue dictValue; + bool success = getParameterDict(params, parameterName, dictValue); + if(!success) + { + if(required) + { + std::string message = _layerName; + message += " layer parameter does not contain "; + message += parameterName; + message += " parameter."; + CV_Error(Error::StsBadArg, message); + } + else + { + return defaultValue; + } + } + return dictValue.get(idx); + } + + void getCodeType(const LayerParams ¶ms) + { + String codeTypeString = params.get("code_type").toLowerCase(); + if (codeTypeString == "corner") + _codeType = caffe::PriorBoxParameter_CodeType_CORNER; + else if (codeTypeString == "center_size") + _codeType = caffe::PriorBoxParameter_CodeType_CENTER_SIZE; + else + _codeType = caffe::PriorBoxParameter_CodeType_CORNER; + } + + DetectionOutputLayerImpl(const LayerParams ¶ms) + { + _numClasses = getParameter(params, "num_classes"); + _shareLocation = getParameter(params, "share_location"); + _numLocClasses = _shareLocation ? 1 : _numClasses; + _backgroundLabelId = getParameter(params, "background_label_id"); + _varianceEncodedInTarget = getParameter(params, "variance_encoded_in_target", 0, false, false); + _keepTopK = getParameter(params, "keep_top_k"); + _confidenceThreshold = getParameter(params, "confidence_threshold", 0, false, -FLT_MAX); + _topK = getParameter(params, "top_k", 0, false, -1); + + getCodeType(params); + + // Parameters used in nms. + _nmsThreshold = getParameter(params, "nms_threshold"); + CV_Assert(_nmsThreshold > 0.); + + setParamsFrom(params); + } + + void checkInputs(const std::vector &inputs) + { + for (size_t i = 1; i < inputs.size(); i++) + { + CV_Assert(inputs[i]->size == inputs[0]->size); + } + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() > 0); + CV_Assert(inputs[0][0] == inputs[1][0]); + + int numPriors = inputs[2][2] / 4; + CV_Assert((numPriors * _numLocClasses * 4) == inputs[0][1]); + CV_Assert(int(numPriors * _numClasses) == inputs[1][1]); + + // num() and channels() are 1. + // Since the number of bboxes to be kept is unknown before nms, we manually + // set it to (fake) 1. + // Each row is a 7 dimension std::vector, which stores + // [image_id, label, confidence, xmin, ymin, xmax, ymax] + outputs.resize(1, shape(1, 1, 1, 7)); + + return false; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + const float* locationData = inputs[0]->ptr(); + const float* confidenceData = inputs[1]->ptr(); + const float* priorData = inputs[2]->ptr(); + + int num = inputs[0]->size[0]; + int numPriors = inputs[2]->size[2] / 4; + + // Retrieve all location predictions. + std::vector allLocationPredictions; + GetLocPredictions(locationData, num, numPriors, _numLocClasses, + _shareLocation, &allLocationPredictions); + + // Retrieve all confidences. + std::vector > > allConfidenceScores; + GetConfidenceScores(confidenceData, num, numPriors, _numClasses, + &allConfidenceScores); + + // Retrieve all prior bboxes. It is same within a batch since we assume all + // images in a batch are of same dimension. + std::vector priorBBoxes; + std::vector > priorVariances; + GetPriorBBoxes(priorData, numPriors, &priorBBoxes, &priorVariances); + + const bool clip_bbox = false; + // Decode all loc predictions to bboxes. + std::vector allDecodedBBoxes; + DecodeBBoxesAll(allLocationPredictions, priorBBoxes, priorVariances, num, + _shareLocation, _numLocClasses, _backgroundLabelId, + _codeType, _varianceEncodedInTarget, clip_bbox, &allDecodedBBoxes); + + int numKept = 0; + std::vector > > allIndices; + for (int i = 0; i < num; ++i) + { + const LabelBBox& decodeBBoxes = allDecodedBBoxes[i]; + const std::map >& confidenceScores = + allConfidenceScores[i]; + std::map > indices; + int numDetections = 0; + for (int c = 0; c < (int)_numClasses; ++c) + { + if (c == _backgroundLabelId) + { + // Ignore background class. + continue; + } + if (confidenceScores.find(c) == confidenceScores.end()) + { + // Something bad happened if there are no predictions for current label. + util::make_error("Could not find confidence predictions for label ", c); + } + + const std::vector& scores = confidenceScores.find(c)->second; + int label = _shareLocation ? -1 : c; + if (decodeBBoxes.find(label) == decodeBBoxes.end()) + { + // Something bad happened if there are no predictions for current label. + util::make_error("Could not find location predictions for label ", label); + continue; + } + const std::vector& bboxes = + decodeBBoxes.find(label)->second; + ApplyNMSFast(bboxes, scores, _confidenceThreshold, _nmsThreshold, 1.0, + _topK, &(indices[c])); + numDetections += indices[c].size(); + } + if (_keepTopK > -1 && numDetections > _keepTopK) + { + std::vector > > scoreIndexPairs; + for (std::map >::iterator it = indices.begin(); + it != indices.end(); ++it) + { + int label = it->first; + const std::vector& labelIndices = it->second; + if (confidenceScores.find(label) == confidenceScores.end()) + { + // Something bad happened for current label. + util::make_error("Could not find location predictions for label ", label); + continue; + } + const std::vector& scores = confidenceScores.find(label)->second; + for (size_t j = 0; j < labelIndices.size(); ++j) + { + size_t idx = labelIndices[j]; + CV_Assert(idx < scores.size()); + scoreIndexPairs.push_back( + std::make_pair(scores[idx], std::make_pair(label, idx))); + } + } + // Keep outputs k results per image. + std::sort(scoreIndexPairs.begin(), scoreIndexPairs.end(), + util::SortScorePairDescend >); + scoreIndexPairs.resize(_keepTopK); + // Store the new indices. + std::map > newIndices; + for (size_t j = 0; j < scoreIndexPairs.size(); ++j) + { + int label = scoreIndexPairs[j].second.first; + int idx = scoreIndexPairs[j].second.second; + newIndices[label].push_back(idx); + } + allIndices.push_back(newIndices); + numKept += _keepTopK; + } + else + { + allIndices.push_back(indices); + numKept += numDetections; + } + } + + if (numKept == 0) + { + CV_ErrorNoReturn(Error::StsError, "Couldn't find any detections"); + return; + } + int outputShape[] = {1, 1, numKept, 7}; + outputs[0].create(4, outputShape, CV_32F); + float* outputsData = outputs[0].ptr(); + + int count = 0; + for (int i = 0; i < num; ++i) + { + const std::map >& confidenceScores = + allConfidenceScores[i]; + const LabelBBox& decodeBBoxes = allDecodedBBoxes[i]; + for (std::map >::iterator it = allIndices[i].begin(); + it != allIndices[i].end(); ++it) + { + int label = it->first; + if (confidenceScores.find(label) == confidenceScores.end()) + { + // Something bad happened if there are no predictions for current label. + util::make_error("Could not find confidence predictions for label ", label); + continue; + } + const std::vector& scores = confidenceScores.find(label)->second; + int locLabel = _shareLocation ? -1 : label; + if (decodeBBoxes.find(locLabel) == decodeBBoxes.end()) + { + // Something bad happened if there are no predictions for current label. + util::make_error("Could not find location predictions for label ", locLabel); + continue; + } + const std::vector& bboxes = + decodeBBoxes.find(locLabel)->second; + std::vector& indices = it->second; + + for (size_t j = 0; j < indices.size(); ++j) + { + int idx = indices[j]; + outputsData[count * 7] = i; + outputsData[count * 7 + 1] = label; + outputsData[count * 7 + 2] = scores[idx]; + caffe::NormalizedBBox clipBBox = bboxes[idx]; + outputsData[count * 7 + 3] = clipBBox.xmin(); + outputsData[count * 7 + 4] = clipBBox.ymin(); + outputsData[count * 7 + 5] = clipBBox.xmax(); + outputsData[count * 7 + 6] = clipBBox.ymax(); + + ++count; + } + } + } + } + + // Compute bbox size. + float BBoxSize(const caffe::NormalizedBBox& bbox, + const bool normalized=true) + { + if (bbox.xmax() < bbox.xmin() || bbox.ymax() < bbox.ymin()) + { + // If bbox is invalid (e.g. xmax < xmin or ymax < ymin), return 0. + return 0; + } + else + { + if (bbox.has_size()) + { + return bbox.size(); + } + else + { + float width = bbox.xmax() - bbox.xmin(); + float height = bbox.ymax() - bbox.ymin(); + if (normalized) + { + return width * height; + } + else + { + // If bbox is not within range [0, 1]. + return (width + 1) * (height + 1); + } + } + } + } + + // Clip the caffe::NormalizedBBox such that the range for each corner is [0, 1]. + void ClipBBox(const caffe::NormalizedBBox& bbox, + caffe::NormalizedBBox* clipBBox) + { + clipBBox->set_xmin(std::max(std::min(bbox.xmin(), 1.f), 0.f)); + clipBBox->set_ymin(std::max(std::min(bbox.ymin(), 1.f), 0.f)); + clipBBox->set_xmax(std::max(std::min(bbox.xmax(), 1.f), 0.f)); + clipBBox->set_ymax(std::max(std::min(bbox.ymax(), 1.f), 0.f)); + clipBBox->clear_size(); + clipBBox->set_size(BBoxSize(*clipBBox)); + clipBBox->set_difficult(bbox.difficult()); + } + + // Decode a bbox according to a prior bbox. + void DecodeBBox( + const caffe::NormalizedBBox& prior_bbox, const std::vector& prior_variance, + const CodeType code_type, const bool variance_encoded_in_target, + const bool clip_bbox, const caffe::NormalizedBBox& bbox, + caffe::NormalizedBBox* decode_bbox) { + if (code_type == caffe::PriorBoxParameter_CodeType_CORNER) { + if (variance_encoded_in_target) { + // variance is encoded in target, we simply need to add the offset + // predictions. + decode_bbox->set_xmin(prior_bbox.xmin() + bbox.xmin()); + decode_bbox->set_ymin(prior_bbox.ymin() + bbox.ymin()); + decode_bbox->set_xmax(prior_bbox.xmax() + bbox.xmax()); + decode_bbox->set_ymax(prior_bbox.ymax() + bbox.ymax()); + } else { + // variance is encoded in bbox, we need to scale the offset accordingly. + decode_bbox->set_xmin( + prior_bbox.xmin() + prior_variance[0] * bbox.xmin()); + decode_bbox->set_ymin( + prior_bbox.ymin() + prior_variance[1] * bbox.ymin()); + decode_bbox->set_xmax( + prior_bbox.xmax() + prior_variance[2] * bbox.xmax()); + decode_bbox->set_ymax( + prior_bbox.ymax() + prior_variance[3] * bbox.ymax()); + } + } else if (code_type == caffe::PriorBoxParameter_CodeType_CENTER_SIZE) { + float prior_width = prior_bbox.xmax() - prior_bbox.xmin(); + CV_Assert(prior_width > 0); + float prior_height = prior_bbox.ymax() - prior_bbox.ymin(); + CV_Assert(prior_height > 0); + float prior_center_x = (prior_bbox.xmin() + prior_bbox.xmax()) / 2.; + float prior_center_y = (prior_bbox.ymin() + prior_bbox.ymax()) / 2.; + + float decode_bbox_center_x, decode_bbox_center_y; + float decode_bbox_width, decode_bbox_height; + if (variance_encoded_in_target) { + // variance is encoded in target, we simply need to retore the offset + // predictions. + decode_bbox_center_x = bbox.xmin() * prior_width + prior_center_x; + decode_bbox_center_y = bbox.ymin() * prior_height + prior_center_y; + decode_bbox_width = exp(bbox.xmax()) * prior_width; + decode_bbox_height = exp(bbox.ymax()) * prior_height; + } else { + // variance is encoded in bbox, we need to scale the offset accordingly. + decode_bbox_center_x = + prior_variance[0] * bbox.xmin() * prior_width + prior_center_x; + decode_bbox_center_y = + prior_variance[1] * bbox.ymin() * prior_height + prior_center_y; + decode_bbox_width = + exp(prior_variance[2] * bbox.xmax()) * prior_width; + decode_bbox_height = + exp(prior_variance[3] * bbox.ymax()) * prior_height; + } + + decode_bbox->set_xmin(decode_bbox_center_x - decode_bbox_width / 2.); + decode_bbox->set_ymin(decode_bbox_center_y - decode_bbox_height / 2.); + decode_bbox->set_xmax(decode_bbox_center_x + decode_bbox_width / 2.); + decode_bbox->set_ymax(decode_bbox_center_y + decode_bbox_height / 2.); + } else { + CV_Error(Error::StsBadArg, "Unknown LocLossType."); + } + float bbox_size = BBoxSize(*decode_bbox); + decode_bbox->set_size(bbox_size); + if (clip_bbox) { + ClipBBox(*decode_bbox, decode_bbox); + } + } + + // Decode a set of bboxes according to a set of prior bboxes. + void DecodeBBoxes( + const std::vector& prior_bboxes, + const std::vector >& prior_variances, + const CodeType code_type, const bool variance_encoded_in_target, + const bool clip_bbox, const std::vector& bboxes, + std::vector* decode_bboxes) { + CV_Assert(prior_bboxes.size() == prior_variances.size()); + CV_Assert(prior_bboxes.size() == bboxes.size()); + int num_bboxes = prior_bboxes.size(); + if (num_bboxes >= 1) { + CV_Assert(prior_variances[0].size() == 4); + } + decode_bboxes->clear(); + for (int i = 0; i < num_bboxes; ++i) { + caffe::NormalizedBBox decode_bbox; + DecodeBBox(prior_bboxes[i], prior_variances[i], code_type, + variance_encoded_in_target, clip_bbox, bboxes[i], &decode_bbox); + decode_bboxes->push_back(decode_bbox); + } + } + + // Decode all bboxes in a batch. + void DecodeBBoxesAll(const std::vector& all_loc_preds, + const std::vector& prior_bboxes, + const std::vector >& prior_variances, + const int num, const bool share_location, + const int num_loc_classes, const int background_label_id, + const CodeType code_type, const bool variance_encoded_in_target, + const bool clip, std::vector* all_decode_bboxes) { + CV_Assert(all_loc_preds.size() == num); + all_decode_bboxes->clear(); + all_decode_bboxes->resize(num); + for (int i = 0; i < num; ++i) { + // Decode predictions into bboxes. + LabelBBox& decode_bboxes = (*all_decode_bboxes)[i]; + for (int c = 0; c < num_loc_classes; ++c) { + int label = share_location ? -1 : c; + if (label == background_label_id) { + // Ignore background class. + continue; + } + if (all_loc_preds[i].find(label) == all_loc_preds[i].end()) { + // Something bad happened if there are no predictions for current label. + util::make_error("Could not find location predictions for label ", label); + } + const std::vector& label_loc_preds = + all_loc_preds[i].find(label)->second; + DecodeBBoxes(prior_bboxes, prior_variances, + code_type, variance_encoded_in_target, clip, + label_loc_preds, &(decode_bboxes[label])); + } + } + } + + // Get prior bounding boxes from prior_data. + // prior_data: 1 x 2 x num_priors * 4 x 1 blob. + // num_priors: number of priors. + // prior_bboxes: stores all the prior bboxes in the format of caffe::NormalizedBBox. + // prior_variances: stores all the variances needed by prior bboxes. + void GetPriorBBoxes(const float* priorData, const int& numPriors, + std::vector* priorBBoxes, + std::vector >* priorVariances) + { + priorBBoxes->clear(); + priorVariances->clear(); + for (int i = 0; i < numPriors; ++i) + { + int startIdx = i * 4; + caffe::NormalizedBBox bbox; + bbox.set_xmin(priorData[startIdx]); + bbox.set_ymin(priorData[startIdx + 1]); + bbox.set_xmax(priorData[startIdx + 2]); + bbox.set_ymax(priorData[startIdx + 3]); + float bboxSize = BBoxSize(bbox); + bbox.set_size(bboxSize); + priorBBoxes->push_back(bbox); + } + + for (int i = 0; i < numPriors; ++i) + { + int startIdx = (numPriors + i) * 4; + std::vector var; + for (int j = 0; j < 4; ++j) + { + var.push_back(priorData[startIdx + j]); + } + priorVariances->push_back(var); + } + } + + // Scale the caffe::NormalizedBBox w.r.t. height and width. + void ScaleBBox(const caffe::NormalizedBBox& bbox, + const int height, const int width, + caffe::NormalizedBBox* scaleBBox) + { + scaleBBox->set_xmin(bbox.xmin() * width); + scaleBBox->set_ymin(bbox.ymin() * height); + scaleBBox->set_xmax(bbox.xmax() * width); + scaleBBox->set_ymax(bbox.ymax() * height); + scaleBBox->clear_size(); + bool normalized = !(width > 1 || height > 1); + scaleBBox->set_size(BBoxSize(*scaleBBox, normalized)); + scaleBBox->set_difficult(bbox.difficult()); + } + + // Get location predictions from loc_data. + // loc_data: num x num_preds_per_class * num_loc_classes * 4 blob. + // num: the number of images. + // num_preds_per_class: number of predictions per class. + // num_loc_classes: number of location classes. It is 1 if share_location is + // true; and is equal to number of classes needed to predict otherwise. + // share_location: if true, all classes share the same location prediction. + // loc_preds: stores the location prediction, where each item contains + // location prediction for an image. + void GetLocPredictions(const float* locData, const int num, + const int numPredsPerClass, const int numLocClasses, + const bool shareLocation, std::vector* locPreds) + { + locPreds->clear(); + if (shareLocation) + { + CV_Assert(numLocClasses == 1); + } + locPreds->resize(num); + for (int i = 0; i < num; ++i) + { + LabelBBox& labelBBox = (*locPreds)[i]; + for (int p = 0; p < numPredsPerClass; ++p) + { + int startIdx = p * numLocClasses * 4; + for (int c = 0; c < numLocClasses; ++c) + { + int label = shareLocation ? -1 : c; + if (labelBBox.find(label) == labelBBox.end()) + { + labelBBox[label].resize(numPredsPerClass); + } + labelBBox[label][p].set_xmin(locData[startIdx + c * 4]); + labelBBox[label][p].set_ymin(locData[startIdx + c * 4 + 1]); + labelBBox[label][p].set_xmax(locData[startIdx + c * 4 + 2]); + labelBBox[label][p].set_ymax(locData[startIdx + c * 4 + 3]); + } + } + locData += numPredsPerClass * numLocClasses * 4; + } + } + + // Get confidence predictions from conf_data. + // conf_data: num x num_preds_per_class * num_classes blob. + // num: the number of images. + // num_preds_per_class: number of predictions per class. + // num_classes: number of classes. + // conf_preds: stores the confidence prediction, where each item contains + // confidence prediction for an image. + void GetConfidenceScores(const float* confData, const int num, + const int numPredsPerClass, const int numClasses, + std::vector > >* confPreds) + { + confPreds->clear(); + confPreds->resize(num); + for (int i = 0; i < num; ++i) + { + std::map >& labelScores = (*confPreds)[i]; + for (int p = 0; p < numPredsPerClass; ++p) + { + int startIdx = p * numClasses; + for (int c = 0; c < numClasses; ++c) + { + labelScores[c].push_back(confData[startIdx + c]); + } + } + confData += numPredsPerClass * numClasses; + } + } + + // Do non maximum suppression given bboxes and scores. + // Inspired by Piotr Dollar's NMS implementation in EdgeBox. + // https://goo.gl/jV3JYS + // bboxes: a set of bounding boxes. + // scores: a set of corresponding confidences. + // score_threshold: a threshold used to filter detection results. + // nms_threshold: a threshold used in non maximum suppression. + // top_k: if not -1, keep at most top_k picked indices. + // indices: the kept indices of bboxes after nms. + void ApplyNMSFast(const std::vector& bboxes, + const std::vector& scores, const float score_threshold, + const float nms_threshold, const float eta, const int top_k, + std::vector* indices) { + // Sanity check. + CV_Assert(bboxes.size() == scores.size()); + + // Get top_k scores (with corresponding indices). + std::vector > score_index_vec; + GetMaxScoreIndex(scores, score_threshold, top_k, &score_index_vec); + + // Do nms. + float adaptive_threshold = nms_threshold; + indices->clear(); + while (score_index_vec.size() != 0) { + const int idx = score_index_vec.front().second; + bool keep = true; + for (int k = 0; k < indices->size(); ++k) { + if (keep) { + const int kept_idx = (*indices)[k]; + float overlap = JaccardOverlap(bboxes[idx], bboxes[kept_idx]); + keep = overlap <= adaptive_threshold; + } else { + break; + } + } + if (keep) { + indices->push_back(idx); + } + score_index_vec.erase(score_index_vec.begin()); + if (keep && eta < 1 && adaptive_threshold > 0.5) { + adaptive_threshold *= eta; + } + } + } + + // Get max scores with corresponding indices. + // scores: a set of scores. + // threshold: only consider scores higher than the threshold. + // top_k: if -1, keep all; otherwise, keep at most top_k. + // score_index_vec: store the sorted (score, index) pair. + void GetMaxScoreIndex(const std::vector& scores, const float threshold,const int top_k, + std::vector >* score_index_vec) + { + // Generate index score pairs. + for (size_t i = 0; i < scores.size(); ++i) + { + if (scores[i] > threshold) + { + score_index_vec->push_back(std::make_pair(scores[i], i)); + } + } + + // Sort the score pair according to the scores in descending order + std::stable_sort(score_index_vec->begin(), score_index_vec->end(), + util::SortScorePairDescend); + + // Keep top_k scores if needed. + if (top_k > -1 && top_k < (int)score_index_vec->size()) + { + score_index_vec->resize(top_k); + } + } + + // Compute the intersection between two bboxes. + void IntersectBBox(const caffe::NormalizedBBox& bbox1, + const caffe::NormalizedBBox& bbox2, + caffe::NormalizedBBox* intersect_bbox) { + if (bbox2.xmin() > bbox1.xmax() || bbox2.xmax() < bbox1.xmin() || + bbox2.ymin() > bbox1.ymax() || bbox2.ymax() < bbox1.ymin()) + { + // Return [0, 0, 0, 0] if there is no intersection. + intersect_bbox->set_xmin(0); + intersect_bbox->set_ymin(0); + intersect_bbox->set_xmax(0); + intersect_bbox->set_ymax(0); + } + else + { + intersect_bbox->set_xmin(std::max(bbox1.xmin(), bbox2.xmin())); + intersect_bbox->set_ymin(std::max(bbox1.ymin(), bbox2.ymin())); + intersect_bbox->set_xmax(std::min(bbox1.xmax(), bbox2.xmax())); + intersect_bbox->set_ymax(std::min(bbox1.ymax(), bbox2.ymax())); + } + } + + // Compute the jaccard (intersection over union IoU) overlap between two bboxes. + float JaccardOverlap(const caffe::NormalizedBBox& bbox1, + const caffe::NormalizedBBox& bbox2, + const bool normalized=true) + { + caffe::NormalizedBBox intersect_bbox; + IntersectBBox(bbox1, bbox2, &intersect_bbox); + float intersect_width, intersect_height; + if (normalized) + { + intersect_width = intersect_bbox.xmax() - intersect_bbox.xmin(); + intersect_height = intersect_bbox.ymax() - intersect_bbox.ymin(); + } + else + { + intersect_width = intersect_bbox.xmax() - intersect_bbox.xmin() + 1; + intersect_height = intersect_bbox.ymax() - intersect_bbox.ymin() + 1; + } + if (intersect_width > 0 && intersect_height > 0) + { + float intersect_size = intersect_width * intersect_height; + float bbox1_size = BBoxSize(bbox1); + float bbox2_size = BBoxSize(bbox2); + return intersect_size / (bbox1_size + bbox2_size - intersect_size); + } + else + { + return 0.; + } + } +}; + +const std::string DetectionOutputLayerImpl::_layerName = std::string("DetectionOutput"); + +Ptr DetectionOutputLayer::create(const LayerParams ¶ms) +{ + return Ptr(new DetectionOutputLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/elementwise_layers.cpp b/modules/dnn/src/layers/elementwise_layers.cpp new file mode 100644 index 0000000000..97f75847ac --- /dev/null +++ b/modules/dnn/src/layers/elementwise_layers.cpp @@ -0,0 +1,502 @@ +#include "../precomp.hpp" +#include "op_halide.hpp" +#include "opencv2/imgproc.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +using std::abs; +using std::exp; +using std::tanh; +using std::pow; + +template +class ElementWiseLayer : public Func::Layer +{ +public: + class PBody : public cv::ParallelLoopBody + { + public: + const Func* func_; + const Mat* src_; + Mat* dst_; + int nstripes_; + + PBody(const Func &func, const Mat &src, Mat& dst, int nstripes) + { + func_ = &func; + src_ = &src; + dst_ = &dst; + nstripes_ = nstripes; + } + + void operator()(const Range &r) const + { + int nstripes = nstripes_, nsamples, outCn; + size_t planeSize; + + if( src_->dims == 4 ) + { + nsamples = src_->size[0]; + outCn = src_->size[1]; + planeSize = (size_t)src_->size[2]*src_->size[3]; + } + else + { + nsamples = outCn = 1; + planeSize = (size_t)src_->total(); + } + + size_t stripeSize = (planeSize + nstripes - 1)/nstripes; + size_t stripeStart = r.start*stripeSize; + size_t stripeEnd = std::min(r.end*stripeSize, planeSize); + + for( int i = 0; i < nsamples; i++ ) + { + const float* srcptr = src_->ptr(i) + stripeStart; + float* dstptr = dst_->ptr(i) + stripeStart; + func_->apply(srcptr, dstptr, (int)(stripeEnd - stripeStart), planeSize, 0, outCn); + } + } + }; + + ElementWiseLayer(const Func &f=Func()) { func = f; } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide(); + } + + virtual Ptr tryAttach(const Ptr& node) + { + switch (node->backendId) + { + case DNN_BACKEND_HALIDE: + { +#ifdef HAVE_HALIDE + auto base = node.dynamicCast(); + Halide::Func& input = base->funcs.back(); + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (this->name.empty() ? Halide::Func() : Halide::Func(this->name)); + func.attachHalide(input(x, y, c, n), top); + return Ptr(new HalideBackendNode(base, top)); +#endif // HAVE_HALIDE + break; + } + } + return Ptr(); + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer input = halideBuffer(inputs[0]); + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (this->name.empty() ? Halide::Func() : Halide::Func(this->name)); + func.attachHalide(input(x, y, c, n), top); + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals); + return true; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for (size_t i = 0; i < inputs.size(); i++) + { + const Mat &src = *inputs[i]; + Mat &dst = outputs[i]; + CV_Assert(src.size == dst.size && src.type() == dst.type() && + src.isContinuous() && dst.isContinuous() && src.type() == CV_32F); + + const int nstripes = getNumThreads(); + PBody body(func, src, dst, nstripes); + parallel_for_(Range(0, nstripes), body, nstripes); + } + } + + void forwardSlice(const float* src, float* dst, int len, size_t planeSize, int cn0, int cn1) const + { + func.apply(src, dst, len, planeSize, cn0, cn1); + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + long flops = 0; + for (int i = 0; i < outputs.size(); i++) + { + flops += total(outputs[i]) * func.getFLOPSPerElement(); + } + return flops; + } + + Func func; + bool run_parallel; +}; + +struct ReLUFunctor +{ + typedef ReLULayer Layer; + float slope; + + explicit ReLUFunctor(float slope_=1.f) : slope(slope_) {} + + void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const + { + float s = slope; + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + int i = 0; +#if CV_SIMD128 + v_float32x4 s4 = v_setall_f32(s), z = v_setzero_f32(); + for( ; i <= len - 16; i += 16 ) + { + v_float32x4 x0 = v_load(srcptr + i); + v_float32x4 x1 = v_load(srcptr + i + 4); + v_float32x4 x2 = v_load(srcptr + i + 8); + v_float32x4 x3 = v_load(srcptr + i + 12); + x0 = v_select(x0 >= z, x0, x0*s4); + x1 = v_select(x1 >= z, x1, x1*s4); + x2 = v_select(x2 >= z, x2, x2*s4); + x3 = v_select(x3 >= z, x3, x3*s4); + v_store(dstptr + i, x0); + v_store(dstptr + i + 4, x1); + v_store(dstptr + i + 8, x2); + v_store(dstptr + i + 12, x3); + } +#endif + for( ; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = x >= 0.f ? x : s*x; + } + } + } + +#ifdef HAVE_HALIDE + void attachHalide(const Halide::Expr& input, Halide::Func& top) + { + Halide::Var x("x"), y("y"), c("c"), n("n"); + if (slope) + { + top(x, y, c, n) = select(input >= 0.0f, input, slope); + } + else + { + top(x, y, c, n) = max(input, 0.0f); + } + } +#endif // HAVE_HALIDE + + int64 getFLOPSPerElement() const { return 1; } +}; + +struct TanHFunctor +{ + typedef TanHLayer Layer; + + void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const + { + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + for( int i = 0; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = tanh(x); + } + } + } + +#ifdef HAVE_HALIDE + void attachHalide(const Halide::Expr& input, Halide::Func& top) + { + Halide::Var x("x"), y("y"), c("c"), n("n"); + top(x, y, c, n) = tanh(input); + } +#endif // HAVE_HALIDE + + int64 getFLOPSPerElement() const { return 1; } +}; + +struct SigmoidFunctor +{ + typedef SigmoidLayer Layer; + + void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const + { + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + for( int i = 0; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = 1.f/(1.f + exp(-x)); + } + } + } + +#ifdef HAVE_HALIDE + void attachHalide(const Halide::Expr& input, Halide::Func& top) + { + Halide::Var x("x"), y("y"), c("c"), n("n"); + top(x, y, c, n) = 1.0f / (1.0f + exp(-input)); + } +#endif // HAVE_HALIDE + + int64 getFLOPSPerElement() const { return 3; } +}; + +struct AbsValFunctor +{ + typedef AbsLayer Layer; + + void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const + { + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + for( int i = 0; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = abs(x); + } + } + } + +#ifdef HAVE_HALIDE + void attachHalide(const Halide::Expr& input, Halide::Func& top) + { + Halide::Var x("x"), y("y"), c("c"), n("n"); + top(x, y, c, n) = abs(input); + } +#endif // HAVE_HALIDE + + int64 getFLOPSPerElement() const { return 1; } +}; + +struct BNLLFunctor +{ + typedef BNLLLayer Layer; + + void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const + { + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + for( int i = 0; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = log(1.f + exp(-abs(x))); + } + } + } + +#ifdef HAVE_HALIDE + void attachHalide(const Halide::Expr& input, Halide::Func& top) + { + Halide::Var x("x"), y("y"), c("c"), n("n"); + top(x, y, c, n) = log(1.0f + exp(-abs(input))); + } +#endif // HAVE_HALIDE + + int64 getFLOPSPerElement() const { return 5; } +}; + +struct PowerFunctor +{ + typedef PowerLayer Layer; + + float power; + float scale; + float shift; + + explicit PowerFunctor(float power_ = 1.f, float scale_ = 1.f, float shift_ = 0.f) + : power(power_), scale(scale_), shift(shift_) {} + + void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const + { + float a = scale, b = shift, p = power; + if( p == 1.f ) + { + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + for( int i = 0; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = a*x + b; + } + } + } + else + { + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + for( int i = 0; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = pow(a*x + b, p); + } + } + } + } + +#ifdef HAVE_HALIDE + void attachHalide(const Halide::Expr& input, Halide::Func& top) + { + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Expr topExpr = (scale == 1.0f ? input : input * scale); + if (shift) + { + topExpr += shift; + } + if (power != 1.0f) + { + topExpr = pow(topExpr, power); + } + top(x, y, c, n) = topExpr; + } +#endif // HAVE_HALIDE + + int64 getFLOPSPerElement() const { return power == 1 ? 2 : 10; } +}; + + +struct ChannelsPReLUFunctor +{ + typedef ChannelsPReLULayer Layer; + Mat scale; + + explicit ChannelsPReLUFunctor(const Mat& scale_=Mat()) : scale(scale_) + { + } + + void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const + { + CV_Assert(scale.isContinuous() && scale.type() == CV_32F); + + const float* scaleptr = scale.ptr(); + CV_Assert( 0 <= cn0 && cn0 < cn1 && cn1 <= (int)scale.total() ); + + for( int cn = cn0; cn < cn1; cn++, srcptr += planeSize, dstptr += planeSize ) + { + float s = scaleptr[cn]; + int i = 0; + #if CV_SIMD128 + v_float32x4 s4 = v_setall_f32(s), z = v_setzero_f32(); + for( ; i <= len - 16; i += 16 ) + { + v_float32x4 x0 = v_load(ptr + i); + v_float32x4 x1 = v_load(ptr + i + 4); + v_float32x4 x2 = v_load(ptr + i + 8); + v_float32x4 x3 = v_load(ptr + i + 12); + x0 = v_select(x0 >= z, x0, x0*s4); + x1 = v_select(x1 >= z, x1, x1*s4); + x2 = v_select(x2 >= z, x2, x2*s4); + x3 = v_select(x3 >= z, x3, x3*s4); + v_store(ptr + i, x0); + v_store(ptr + i + 4, x1); + v_store(ptr + i + 8, x2); + v_store(ptr + i + 12, x3); + } + #endif + for( ; i < len; i++ ) + { + float x = srcptr[i]; + dstptr[i] = x >= 0.f ? x : s*x; + } + } + } + +#ifdef HAVE_HALIDE + void attachHalide(const Halide::Expr& input, Halide::Func& top) + { + Halide::Var x("x"), y("y"), c("c"), n("n"); + auto weights = wrapToHalideBuffer(scale, {(int)scale.total()}); + top(x, y, c, n) = select(input >= 0.0f, input, weights(c) * input); + } +#endif // HAVE_HALIDE + + int64 getFLOPSPerElement() const { return 1; } +}; + +#define ACTIVATION_CREATOR_FOR(_Layer, _Functor, ...) \ +Ptr<_Layer> _Layer::create() { \ + return return Ptr<_Layer>( new ElementWiseLayer<_Functor>(_Functor()) ); } + + +Ptr ReLULayer::create(const LayerParams& params) +{ + float negativeSlope = params.get("negative_slope", 0.f); + Ptr l(new ElementWiseLayer(ReLUFunctor(negativeSlope))); + l->setParamsFrom(params); + l->negativeSlope = negativeSlope; + + return l; +} + +Ptr TanHLayer::create(const LayerParams& params) +{ + Ptr l(new ElementWiseLayer()); + l->setParamsFrom(params); + + return l; +} + +Ptr SigmoidLayer::create(const LayerParams& params) +{ + Ptr l(new ElementWiseLayer()); + l->setParamsFrom(params); + + return l; +} + +Ptr AbsLayer::create(const LayerParams& params) +{ + Ptr l(new ElementWiseLayer()); + l->setParamsFrom(params); + + return l; +} + +Ptr BNLLLayer::create(const LayerParams& params) +{ + Ptr l(new ElementWiseLayer()); + l->setParamsFrom(params); + + return l; +} + +Ptr PowerLayer::create(const LayerParams& params) +{ + float power = params.get("power", 1.0f); + float scale = params.get("scale", 1.0f); + float shift = params.get("shift", 0.0f); + Ptr l(new ElementWiseLayer(PowerFunctor(power, scale, shift))); + l->setParamsFrom(params); + l->power = power; + l->scale = scale; + l->shift = shift; + + return l; +} + +Ptr ChannelsPReLULayer::create(const LayerParams& params) +{ + Ptr l(new ElementWiseLayer(ChannelsPReLUFunctor(params.blobs[0]))); + l->setParamsFrom(params); + + return l; +} + +} +} diff --git a/modules/dnn/src/layers/eltwise_layer.cpp b/modules/dnn/src/layers/eltwise_layer.cpp new file mode 100644 index 0000000000..e6126c7c57 --- /dev/null +++ b/modules/dnn/src/layers/eltwise_layer.cpp @@ -0,0 +1,219 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" + +namespace cv +{ +namespace dnn +{ + +class EltwiseLayerImpl : public EltwiseLayer +{ +public: + EltwiseOp op; + std::vector coeffs; + + EltwiseLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + op = EltwiseLayer::SUM; + if (params.has("operation")) + { + String operation = params.get("operation").toLowerCase(); + if (operation == "prod") + op = EltwiseLayer::PROD; + else if (operation == "sum") + op = EltwiseLayer::SUM; + else if (operation == "max") + op = EltwiseLayer::MAX; + else + CV_Error(cv::Error::StsBadArg, "Unknown operaticon type \"" + operation + "\""); + } + + if (params.has("coeff")) + { + DictValue paramCoeff = params.get("coeff"); + int i, n = paramCoeff.size(); + coeffs.resize(n); + for (i = 0; i < n; i++) + { + coeffs[i] = paramCoeff.get(i); + } + } + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide(); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() >= 2); + CV_Assert(coeffs.size() == 0 || coeffs.size() == inputs.size()); + CV_Assert(op == SUM || coeffs.size() == 0); + + for (int i = 1; i < inputs.size(); i++) + { + CV_Assert(inputs[0] == inputs[i]); + } + + outputs.assign(1, inputs[0]); + + return false; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + Mat& output = outputs[0]; + switch (op) + { + case SUM: + CV_Assert(coeffs.size() == 0 || coeffs.size() == inputs.size()); + if (0 < coeffs.size()) + { + output.setTo(0.); + for (size_t i = 0; i < inputs.size(); i++) + { + output += *inputs[i] * coeffs[i]; + } + } + else + { + add(*inputs[0], *inputs[1], output); + for (size_t i = 2; i < inputs.size(); i++) + { + output += *inputs[i]; + } + } + break; + case PROD: + output.setTo(1.); + for (size_t i = 0; i < inputs.size(); i++) + { + output = output.mul(*inputs[i]); + } + break; + case MAX: + cv::max(*inputs[0], *inputs[1], output); + for (size_t i = 2; i < inputs.size(); i++) + { + cv::max(output, *inputs[i], output); + } + break; + default: + CV_Assert(0); + break; + } + } + + virtual Ptr initHalide(const std::vector > &input) + { +#ifdef HAVE_HALIDE + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Expr topExpr; + std::vector > inputBuffers = halideBuffers(input); + switch (op) + { + case SUM: + if (coeffs.empty()) + { + topExpr = inputBuffers[0](x, y, c, n) + + inputBuffers[1](x, y, c, n); + for (int i = 2; i < inputBuffers.size(); ++i) + topExpr += inputBuffers[i](x, y, c, n); + } + else + { + topExpr = coeffs[0] * inputBuffers[0](x, y, c, n) + + coeffs[1] * inputBuffers[1](x, y, c, n); + for (int i = 2; i < inputBuffers.size(); ++i) + topExpr += coeffs[i] * inputBuffers[i](x, y, c, n); + } + break; + case PROD: + topExpr = inputBuffers[0](x, y, c, n) * + inputBuffers[1](x, y, c, n); + for (int i = 2; i < inputBuffers.size(); ++i) + topExpr *= inputBuffers[i](x, y, c, n); + break; + case MAX: + topExpr = max(inputBuffers[0](x, y, c, n), + inputBuffers[1](x, y, c, n)); + for (int i = 2; i < inputBuffers.size(); ++i) + topExpr = max(topExpr, inputBuffers[i](x, y, c, n)); + break; + default: + return Ptr(); + } + top(x, y, c, n) = topExpr; + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + CV_Assert(inputs.size()); + + long flops = inputs.size() * total(inputs[0]); + + return flops; + } +}; + +Ptr EltwiseLayer::create(const LayerParams& params) +{ + return Ptr(new EltwiseLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/flatten_layer.cpp b/modules/dnn/src/layers/flatten_layer.cpp new file mode 100644 index 0000000000..78b373401a --- /dev/null +++ b/modules/dnn/src/layers/flatten_layer.cpp @@ -0,0 +1,125 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include +#include +#include + +namespace cv +{ +namespace dnn +{ + +class FlattenLayerImpl : public FlattenLayer +{ +public: + FlattenLayerImpl(const LayerParams ¶ms) + { + _startAxis = params.get("axis", 1); + _endAxis = params.get("end_axis", -1); + setParamsFrom(params); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() > 0); + for (size_t i = 1; i < inputs.size(); i++) + { + CV_Assert(inputs[i] == inputs[0]); + } + + int numAxes = inputs[0].size(); + int startAxis = clamp(_startAxis, numAxes); + int endAxis = clamp(_endAxis, numAxes); + + for (size_t i = 1; i < inputs.size(); i++) + { + CV_Assert(inputs[i] == inputs[0]); + } + + + CV_Assert(startAxis >= 0); + CV_Assert(endAxis >= startAxis && endAxis < (int)numAxes); + + size_t flattenedDimensionSize = total(inputs[0], startAxis, endAxis + 1); + + MatShape outputShapeVec; + for (int i = 0; i < startAxis; i++) + { + outputShapeVec.push_back(inputs[0][i]); + } + outputShapeVec.push_back(flattenedDimensionSize); + for (size_t i = endAxis + 1; i < numAxes; i++) + { + outputShapeVec.push_back(inputs[0][i]); + } + CV_Assert(outputShapeVec.size() <= 4); + + outputs.resize(inputs.size(), outputShapeVec); + + return true; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for (size_t i = 0; i < inputs.size(); i++) + { + MatShape outShape = shape(outputs[i]); + outputs[i] = inputs[i]->reshape(1, (int)outShape.size(), &outShape[0]); + } + } + + int _startAxis; + int _endAxis; +}; + +Ptr FlattenLayer::create(const LayerParams& params) +{ + return Ptr(new FlattenLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/fully_connected_layer.cpp b/modules/dnn/src/layers/fully_connected_layer.cpp new file mode 100644 index 0000000000..9f790da63d --- /dev/null +++ b/modules/dnn/src/layers/fully_connected_layer.cpp @@ -0,0 +1,281 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class FullyConnectedLayerImpl : public InnerProductLayer +{ +public: + enum { VEC_ALIGN = 8 }; + + FullyConnectedLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + CV_Assert(1 <= blobs.size() && blobs.size() <= 2); + + int numOutput = params.get("num_output"); + int innerSize = (int)blobs[0].total() / numOutput; + bias = params.get("bias_term", true); + axis = params.get("axis", 1); + + CV_Assert(blobs[0].dims >= 2 && (size_t)(innerSize * numOutput) == blobs[0].total()); + CV_Assert(!bias || (blobs.size() == 2 && (size_t)numOutput == blobs[1].total())); + + weightsMat = blobs[0] = blobs[0].reshape(1, numOutput); + int vecsize = weightsMat.cols; + if( vecsize % VEC_ALIGN != 0 ) + { + int vecsize_aligned = (int)alignSize(vecsize, VEC_ALIGN); + Mat weightsBuf(weightsMat.rows, vecsize_aligned, weightsMat.type()); + Mat wpadding = weightsBuf.colRange(vecsize, vecsize_aligned); + wpadding.setTo(Scalar::all(0.)); + weightsMat = weightsBuf.colRange(0, vecsize); + blobs[0].copyTo(weightsMat); + blobs[0] = weightsMat; + } + + if (bias) + biasMat = blobs[1] = blobs[1].reshape(1, 1); + else + biasMat = Mat::zeros(1, numOutput, weightsMat.type()); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &) const + { + CV_Assert(inputs.size() > 0); + CV_Assert(1 <= blobs.size() && blobs.size() <= 2); + CV_Assert(blobs[0].dims == 2); + + int cAxis = clamp(axis, inputs[0]); + int outerSize = total(inputs[0], 0, cAxis); + int numOutput = blobs[0].size[0]; + outputs.resize(inputs.size(), shape(outerSize, numOutput)); + + CV_Assert(!bias || (size_t)numOutput == blobs[1].total()); + return false; + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide() && axis == 1; + } + + class FullConnected : public ParallelLoopBody + { + public: + FullConnected(const Mat& srcMat, const Mat& weights, const Mat& biasMat, Mat& dstMat, int nstripes) + { + CV_Assert( srcMat.dims == 2 && srcMat.cols == weights.cols && + dstMat.rows == srcMat.rows && dstMat.cols == weights.rows && + srcMat.type() == weights.type() && weights.type() == dstMat.type() && + srcMat.type() == CV_32F && + (biasMat.empty() || (biasMat.type() == srcMat.type() && + biasMat.isContinuous() && (int)biasMat.total() == dstMat.cols)) ); + + srcMat_ = &srcMat; + weights_ = &weights; + biasMat_ = &biasMat; + dstMat_ = &dstMat; + nstripes_ = nstripes; + useAVX2_ = checkHardwareSupport(CPU_AVX2); + } + + void operator()(const Range& r) const + { + int valign = FullyConnectedLayerImpl::VEC_ALIGN; + int nsamples = srcMat_->rows; + int nw0 = weights_->rows; + int k, vecsize = srcMat_->cols; + int vecsize_aligned = (int)alignSize(vecsize, VEC_ALIGN); + int nstripes = nstripes_; + size_t total = (size_t)nsamples*nw0; + size_t stripeSize = (total + nstripes - 1)/nstripes; + size_t stripeStart = r.start*stripeSize; + size_t stripeEnd = r.end == nstripes ? total : std::min(r.end*stripeSize, total); + size_t wstep = weights_->step1(); + AutoBuffer srcbuf(vecsize_aligned + valign); + float* sptr = alignPtr((float*)srcbuf, (int)(valign*sizeof(float))); + + for( k = vecsize; k < vecsize_aligned; k++ ) + sptr[k] = 0.f; + + for( size_t ofs = stripeStart; ofs < stripeEnd; ) + { + int sampleIdx = (int)(ofs / nw0); + int delta = (int)(ofs - (size_t)sampleIdx*nw0); + const float* sptr_ = srcMat_->ptr(sampleIdx); + const float* wptr = weights_->ptr(delta); + float* dptr = dstMat_->ptr(sampleIdx) + delta; + const float* biasptr = biasMat_->ptr() + delta; + int nw = std::min(nw0 - delta, (int)(stripeEnd - ofs)); + + memcpy(sptr, sptr_, vecsize*sizeof(sptr[0])); + + #if CV_DNN_TRY_AVX2 + if( useAVX2_ ) + fastGEMM1T_avx2( sptr, wptr, wstep, biasptr, dptr, nw, vecsize); + else + #endif + { + int i = 0; + + #if CV_SIMD128 + for( ; i <= nw - 4; i += 4, wptr += 4*wstep ) + { + vfloat32x4 vs0 = v_setall_f32(0.f), vs1 = v_setall_f32(0.f); + vfloat32x4 vs2 = v_setall_f32(0.f), vs3 = v_setall_f32(0.f); + + for( k = 0; k < vecsize; k += 4 ) + { + vfloat32x4 v = v_load_aligned(sptr + k); + vs0 += v*v_load_aligned(wptr + k); + vs1 += v*v_load_aligned(wptr + wstep + k); + vs2 += v*v_load_aligned(wptr + wstep*2 + k); + vs3 += v*v_load_aligned(wptr + wstep*3 + k); + } + + vfloat32x4 s = v_reduce_sum4(vs0, vs1, vs2, vs3); + s += v_load(biasptr + i); + v_store(dptr + i, s); + } + #endif + + for( ; i < nw; i++, wptr += wstep ) + { + float s0=biasptr[i]; + + for( k = 0; k < vecsize; k++ ) + { + float v = sptr[k]; + s0 += v*wptr[k]; + } + dptr[i] = s0; + } + } + ofs += nw; + } + } + + const Mat *srcMat_, *weights_, *biasMat_; + Mat* dstMat_; + int nstripes_; + bool useAVX2_; + }; + + void forward(std::vector &input, std::vector &output, std::vector &) + { + int axisCan = clamp(axis, input[0]->dims); + int outerSize = input[0]->total(0, axisCan); + + for (size_t i = 0; i < input.size(); i++) + { + Mat srcMat = input[i]->reshape(1, outerSize); + Mat dstMat = output[i].reshape(1, outerSize); + + const int nstripes = getNumThreads(); + FullConnected fconn(srcMat, weightsMat, biasMat, dstMat, nstripes); + parallel_for_(Range(0, nstripes), fconn, nstripes); + } + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + int inW, inH, inC, inN, outC = blobs[0].size[0]; + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + getCanonicalSize(inputBuffer, &inW, &inH, &inC, &inN); + auto weights = wrapToHalideBuffer(blobs[0], {inW, inH, inC, outC}); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::RDom r(0, inW, 0, inH, 0, inC); + Halide::Expr topExpr = sum(inputBuffer(r.x, r.y, r.z, n) * + weights(r.x, r.y, r.z, c)); + if (bias) + { + Halide::Buffer bias = wrapToHalideBuffer(blobs[1], {outC}); + topExpr += bias(c); + } + top(x, y, c, n) = topExpr; + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)inputs; // suppress unused variable warning + long flops = 0; + + int innerSize = blobs[0].size[1]; + for(int i = 0; i < outputs.size(); i++) + { + flops += 3*innerSize*total(outputs[i]); + } + + return flops; + + } + + bool bias; + Mat weightsMat, biasMat; +}; + +Ptr InnerProductLayer::create(const LayerParams& params) +{ + return Ptr(new FullyConnectedLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/layers_common.avx2.cpp b/modules/dnn/src/layers/layers_common.avx2.cpp new file mode 100644 index 0000000000..8b08ac0230 --- /dev/null +++ b/modules/dnn/src/layers/layers_common.avx2.cpp @@ -0,0 +1,356 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "precomp.hpp" +#include "layers_common.hpp" +#include "opencv2/core/hal/intrin.hpp" + +#if CV_DNN_TRY_AVX2 + +#include + +namespace cv { +namespace dnn { + +void fastConv_avx2( const float* weights, size_t wstep, const float* bias, + const float* rowbuf, float* output, const int* outShape, + int blockSize, int vecsize, int vecsize_aligned, + const float* relu, bool initOutput ) +{ + int outCn = outShape[1]; + size_t outPlaneSize = outShape[2]*outShape[3]; + float r0 = 1.f, r1 = 1.f, r2 = 1.f; + __m256 vr0 = _mm256_set1_ps(1.f), vr1 = vr0, vr2 = vr0, z = _mm256_setzero_ps(); + + // now compute dot product of the weights + // and im2row-transformed part of the tensor + for( int i = 0; i < outCn; i += 3 ) + { + const float* wptr0 = weights + i*wstep; + const float* wptr1 = wptr0 + wstep; + const float* wptr2 = wptr1 + wstep; + float* outptr0 = output + i*outPlaneSize; + float* outptr1 = outptr0 + outPlaneSize; + float* outptr2 = outptr1 + outPlaneSize; + float bias0 = bias[i], bias1 = bias[i+1], bias2 = bias[i+2]; + + if( i+2 >= outCn ) + { + wptr2 = wptr1; + outptr2 = outptr1; + bias2 = bias1; + if( i+1 >= outCn ) + { + wptr2 = wptr1 = wptr0; + outptr2 = outptr1 = outptr0; + bias2 = bias1 = bias0; + } + } + + if( relu ) + { + r0 = relu[i]; + r1 = relu[i+1]; + r2 = relu[i+2]; + vr0 = _mm256_set1_ps(r0); + vr1 = _mm256_set1_ps(r1); + vr2 = _mm256_set1_ps(r2); + } + + int j = 0; + for( ; j <= blockSize - 4; j += 4 ) + { + const float* rptr = rowbuf + j*vecsize_aligned; + + __m256 vs00 = _mm256_setzero_ps(), vs01 = _mm256_setzero_ps(), + vs02 = _mm256_setzero_ps(), vs03 = _mm256_setzero_ps(), + vs10 = _mm256_setzero_ps(), vs11 = _mm256_setzero_ps(), + vs12 = _mm256_setzero_ps(), vs13 = _mm256_setzero_ps(), + vs20 = _mm256_setzero_ps(), vs21 = _mm256_setzero_ps(), + vs22 = _mm256_setzero_ps(), vs23 = _mm256_setzero_ps(); + + for( int k = 0; k < vecsize; k += 8, rptr += 8 ) + { + __m256 w0 = _mm256_load_ps(wptr0 + k); + __m256 w1 = _mm256_load_ps(wptr1 + k); + __m256 w2 = _mm256_load_ps(wptr2 + k); + __m256 r0 = _mm256_load_ps(rptr); + + vs00 = _mm256_fmadd_ps(w0, r0, vs00); + vs10 = _mm256_fmadd_ps(w1, r0, vs10); + vs20 = _mm256_fmadd_ps(w2, r0, vs20); + + r0 = _mm256_load_ps(rptr + vecsize_aligned); + vs01 = _mm256_fmadd_ps(w0, r0, vs01); + vs11 = _mm256_fmadd_ps(w1, r0, vs11); + vs21 = _mm256_fmadd_ps(w2, r0, vs21); + + r0 = _mm256_load_ps(rptr + vecsize_aligned*2); + vs02 = _mm256_fmadd_ps(w0, r0, vs02); + vs12 = _mm256_fmadd_ps(w1, r0, vs12); + vs22 = _mm256_fmadd_ps(w2, r0, vs22); + + r0 = _mm256_load_ps(rptr + vecsize_aligned*3); + vs03 = _mm256_fmadd_ps(w0, r0, vs03); + vs13 = _mm256_fmadd_ps(w1, r0, vs13); + vs23 = _mm256_fmadd_ps(w2, r0, vs23); + } + + __m256 t0 = _mm256_hadd_ps(_mm256_hadd_ps(vs00, vs01), _mm256_hadd_ps(vs02, vs03)); + __m256 t1 = _mm256_hadd_ps(_mm256_hadd_ps(vs10, vs11), _mm256_hadd_ps(vs12, vs13)); + __m256 t2 = _mm256_hadd_ps(_mm256_hadd_ps(vs20, vs21), _mm256_hadd_ps(vs22, vs23)); + + t0 = _mm256_add_ps(t0, _mm256_permute2f128_ps(t0, t0, 1)); + t1 = _mm256_add_ps(t1, _mm256_permute2f128_ps(t1, t1, 1)); + t2 = _mm256_add_ps(t2, _mm256_permute2f128_ps(t2, t2, 1)); + + __m256 s0, s1, s2; + + if( initOutput ) + { + s0 = _mm256_set1_ps(bias0); + s1 = _mm256_set1_ps(bias1); + s2 = _mm256_set1_ps(bias2); + } + else + { + s0 = _mm256_castps128_ps256(_mm_loadu_ps(outptr0 + j)); + s1 = _mm256_castps128_ps256(_mm_loadu_ps(outptr1 + j)); + s2 = _mm256_castps128_ps256(_mm_loadu_ps(outptr2 + j)); + } + + s0 = _mm256_add_ps(s0, t0); + s1 = _mm256_add_ps(s1, t1); + s2 = _mm256_add_ps(s2, t2); + + if( relu ) + { + __m256 m0 = _mm256_cmp_ps(s0, z, _CMP_GT_OS); + __m256 m1 = _mm256_cmp_ps(s1, z, _CMP_GT_OS); + __m256 m2 = _mm256_cmp_ps(s2, z, _CMP_GT_OS); + s0 = _mm256_xor_ps(s0, _mm256_andnot_ps(m0, _mm256_xor_ps(_mm256_mul_ps(s0, vr0), s0))); + s1 = _mm256_xor_ps(s1, _mm256_andnot_ps(m1, _mm256_xor_ps(_mm256_mul_ps(s1, vr1), s1))); + s2 = _mm256_xor_ps(s2, _mm256_andnot_ps(m2, _mm256_xor_ps(_mm256_mul_ps(s2, vr2), s2))); + } + + _mm_storeu_ps(outptr0 + j, _mm256_castps256_ps128(s0)); + _mm_storeu_ps(outptr1 + j, _mm256_castps256_ps128(s1)); + _mm_storeu_ps(outptr2 + j, _mm256_castps256_ps128(s2)); + } + + for( ; j < blockSize; j++ ) + { + const float* rptr = rowbuf + j*vecsize_aligned; + float s00, s10, s20; + + if( initOutput ) + { + s00 = bias0; + s10 = bias1; + s20 = bias2; + } + else + { + s00 = outptr0[j]; + s10 = outptr1[j]; + s20 = outptr2[j]; + } + + for( int k = 0; k < vecsize; k++ ) + { + float r0 = rptr[k]; + s00 += wptr0[k]*r0; + s10 += wptr1[k]*r0; + s20 += wptr2[k]*r0; + } + + if( relu ) + { + s00 = s00 > 0.f ? s00 : s00*r0; + s10 = s10 > 0.f ? s10 : s10*r1; + s20 = s20 > 0.f ? s20 : s20*r2; + } + + outptr0[j] = s00; + outptr1[j] = s10; + outptr2[j] = s20; + } + } + _mm256_zeroupper(); +} + +// dst = vec * weights^t + bias +void fastGEMM1T_avx2( const float* vec, const float* weights, + size_t wstep, const float* bias, + float* dst, int nvecs, int vecsize ) +{ + int i = 0; + + for( ; i <= nvecs - 8; i += 8 ) + { + const float* wptr = weights + i*wstep; + __m256 vs0 = _mm256_setzero_ps(), vs1 = _mm256_setzero_ps(), + vs2 = _mm256_setzero_ps(), vs3 = _mm256_setzero_ps(), + vs4 = _mm256_setzero_ps(), vs5 = _mm256_setzero_ps(), + vs6 = _mm256_setzero_ps(), vs7 = _mm256_setzero_ps(); + + for( int k = 0; k < vecsize; k += 8, wptr += 8 ) + { + __m256 v = _mm256_load_ps(vec + k); + + vs0 = _mm256_fmadd_ps(_mm256_load_ps(wptr), v, vs0); + vs1 = _mm256_fmadd_ps(_mm256_load_ps(wptr + wstep), v, vs1); + vs2 = _mm256_fmadd_ps(_mm256_load_ps(wptr + wstep*2), v, vs2); + vs3 = _mm256_fmadd_ps(_mm256_load_ps(wptr + wstep*3), v, vs3); + vs4 = _mm256_fmadd_ps(_mm256_load_ps(wptr + wstep*4), v, vs4); + vs5 = _mm256_fmadd_ps(_mm256_load_ps(wptr + wstep*5), v, vs5); + vs6 = _mm256_fmadd_ps(_mm256_load_ps(wptr + wstep*6), v, vs6); + vs7 = _mm256_fmadd_ps(_mm256_load_ps(wptr + wstep*7), v, vs7); + } + + __m256 s0 = _mm256_hadd_ps(_mm256_hadd_ps(vs0, vs1), _mm256_hadd_ps(vs2, vs3)); + __m256 s1 = _mm256_hadd_ps(_mm256_hadd_ps(vs4, vs5), _mm256_hadd_ps(vs6, vs7)); + + s0 = _mm256_add_ps(s0, _mm256_permute2f128_ps(s0, s0, 1)); + s1 = _mm256_add_ps(s1, _mm256_permute2f128_ps(s1, s1, 1)); + + s0 = _mm256_add_ps(s0, _mm256_castps128_ps256(_mm_loadu_ps(bias + i))); + s1 = _mm256_add_ps(s1, _mm256_castps128_ps256(_mm_loadu_ps(bias + i + 4))); + + _mm_storeu_ps(dst + i, _mm256_castps256_ps128(s0)); + _mm_storeu_ps(dst + i + 4, _mm256_castps256_ps128(s1)); + } + + float temp = 0.f; + for( ; i < nvecs; i++ ) + { + const float* wptr = weights + i*wstep; + __m256 vs0 = _mm256_setzero_ps(); + + for( int k = 0; k < vecsize; k += 8, wptr += 8 ) + { + __m256 v = _mm256_load_ps(vec + k); + vs0 = _mm256_fmadd_ps(_mm256_load_ps(wptr), v, vs0); + } + + __m256 s0 = _mm256_hadd_ps(_mm256_hadd_ps(vs0, vs0), vs0); + s0 = _mm256_add_ps(s0, _mm256_permute2f128_ps(s0, s0, 1)); + _mm_store_ss(&temp, _mm256_castps256_ps128(s0)); + dst[i] = temp + bias[i]; + } + + _mm256_zeroupper(); +} + +void fastGEMM_avx2( const float* aptr, size_t astep, const float* bptr, + size_t bstep, float* cptr, size_t cstep, + int ma, int na, int nb ) +{ + int n = 0; + for( ; n <= nb - 16; n += 16 ) + { + for( int m = 0; m < ma; m += 4 ) + { + const float* aptr0 = aptr + astep*m; + const float* aptr1 = aptr + astep*std::min(m+1, ma-1); + const float* aptr2 = aptr + astep*std::min(m+2, ma-1); + const float* aptr3 = aptr + astep*std::min(m+3, ma-1); + + float* cptr0 = cptr + cstep*m; + float* cptr1 = cptr + cstep*std::min(m+1, ma-1); + float* cptr2 = cptr + cstep*std::min(m+2, ma-1); + float* cptr3 = cptr + cstep*std::min(m+3, ma-1); + + __m256 d00 = _mm256_setzero_ps(), d01 = _mm256_setzero_ps(); + __m256 d10 = _mm256_setzero_ps(), d11 = _mm256_setzero_ps(); + __m256 d20 = _mm256_setzero_ps(), d21 = _mm256_setzero_ps(); + __m256 d30 = _mm256_setzero_ps(), d31 = _mm256_setzero_ps(); + + for( int k = 0; k < na; k++ ) + { + __m256 a0 = _mm256_set1_ps(aptr0[k]); + __m256 a1 = _mm256_set1_ps(aptr1[k]); + __m256 a2 = _mm256_set1_ps(aptr2[k]); + __m256 a3 = _mm256_set1_ps(aptr3[k]); + __m256 b0 = _mm256_loadu_ps(bptr + k*bstep + n); + __m256 b1 = _mm256_loadu_ps(bptr + k*bstep + n + 8); + d00 = _mm256_fmadd_ps(a0, b0, d00); + d01 = _mm256_fmadd_ps(a0, b1, d01); + d10 = _mm256_fmadd_ps(a1, b0, d10); + d11 = _mm256_fmadd_ps(a1, b1, d11); + d20 = _mm256_fmadd_ps(a2, b0, d20); + d21 = _mm256_fmadd_ps(a2, b1, d21); + d30 = _mm256_fmadd_ps(a3, b0, d30); + d31 = _mm256_fmadd_ps(a3, b1, d31); + } + + _mm256_storeu_ps(cptr0 + n, d00); + _mm256_storeu_ps(cptr0 + n + 8, d01); + _mm256_storeu_ps(cptr1 + n, d10); + _mm256_storeu_ps(cptr1 + n + 8, d11); + _mm256_storeu_ps(cptr2 + n, d20); + _mm256_storeu_ps(cptr2 + n + 8, d21); + _mm256_storeu_ps(cptr3 + n, d30); + _mm256_storeu_ps(cptr3 + n + 8, d31); + } + } + _mm256_zeroupper(); + + for( ; n < nb; n++ ) + { + for( int m = 0; m < ma; m++ ) + { + const float* aptr0 = aptr + astep*m; + float* cptr0 = cptr + cstep*m; + float d0 = 0.f; + + for( int k = 0; k < na; k++ ) + d0 += aptr0[k]*bptr[k*bstep + n]; + + cptr0[n] = d0; + } + } +} + +} +} + +#endif diff --git a/modules/dnn/src/layers/layers_common.cpp b/modules/dnn/src/layers/layers_common.cpp new file mode 100644 index 0000000000..038422baca --- /dev/null +++ b/modules/dnn/src/layers/layers_common.cpp @@ -0,0 +1,205 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "layers_common.hpp" + +namespace cv +{ +namespace dnn +{ + +namespace util +{ + +std::string makeName(const std::string& str1, const std::string& str2) +{ + return str1 + str2; +} + +bool getParameter(const LayerParams ¶ms, const std::string& nameBase, const std::string& nameAll, + int ¶meterH, int ¶meterW, bool hasDefault = false, const int& defaultValue = 0) +{ + std::string nameH = makeName(nameBase, std::string("_h")); + std::string nameW = makeName(nameBase, std::string("_w")); + std::string nameAll_ = nameAll; + if(nameAll_ == "") + { + nameAll_ = nameBase; + } + + if (params.has(nameH) && params.has(nameW)) + { + parameterH = params.get(nameH); + parameterW = params.get(nameW); + return true; + } + else + { + if (params.has(nameAll_)) + { + parameterH = parameterW = params.get(nameAll_); + return true; + } + else + { + if(hasDefault) + { + parameterH = parameterW = defaultValue; + return true; + } + else + { + return false; + } + } + } +} + +void getKernelSize(const LayerParams ¶ms, int &kernelH, int &kernelW) +{ + if(!util::getParameter(params, "kernel", "kernel_size", kernelH, kernelW)) + { + CV_Error(cv::Error::StsBadArg, "kernel_size (or kernel_h and kernel_w) not specified"); + } + + CV_Assert(kernelH > 0 && kernelW > 0); +} + +void getStrideAndPadding(const LayerParams ¶ms, int &padH, int &padW, int &strideH, int &strideW, cv::String& padMode) +{ + util::getParameter(params, "pad", "pad", padH, padW, true, 0); + util::getParameter(params, "stride", "stride", strideH, strideW, true, 1); + + padMode = ""; + if (params.has("pad_mode")) + { + padMode = params.get("pad_mode"); + } + + CV_Assert(padH >= 0 && padW >= 0 && strideH > 0 && strideW > 0); +} +} + + +void getPoolingKernelParams(const LayerParams ¶ms, int &kernelH, int &kernelW, bool &globalPooling, + int &padH, int &padW, int &strideH, int &strideW, cv::String &padMode) +{ + util::getStrideAndPadding(params, padH, padW, strideH, strideW, padMode); + + globalPooling = params.has("global_pooling"); + + if (globalPooling) + { + if(params.has("kernel_h") || params.has("kernel_w") || params.has("kernel_size")) + { + CV_Error(cv::Error::StsBadArg, "In global_pooling mode, kernel_size (or kernel_h and kernel_w) cannot be specified"); + } + if(padH != 0 || padW != 0 || strideH != 1 || strideW != 1) + { + CV_Error(cv::Error::StsBadArg, "In global_pooling mode, pad_h and pad_w must be = 0, and stride_h and stride_w must be = 1"); + } + } + else + { + util::getKernelSize(params, kernelH, kernelW); + } +} + +void getConvolutionKernelParams(const LayerParams ¶ms, int &kernelH, int &kernelW, int &padH, int &padW, + int &strideH, int &strideW, int &dilationH, int &dilationW, cv::String &padMode) +{ + util::getKernelSize(params, kernelH, kernelW); + util::getStrideAndPadding(params, padH, padW, strideH, strideW, padMode); + + util::getParameter(params, "dilation", "dilation", dilationH, dilationW, true, 1); + + CV_Assert(dilationH > 0 && dilationW > 0); +} + +// From TensorFlow code: +// Total padding on rows and cols is +// Pr = (R' - 1) * S + Kr - R +// Pc = (C' - 1) * S + Kc - C +// where (R', C') are output dimensions, (R, C) are input dimensions, S +// is stride, (Kr, Kc) are filter dimensions. +// We pad Pr/2 on the left and Pr - Pr/2 on the right, Pc/2 on the top +// and Pc - Pc/2 on the bottom. When Pr or Pc is odd, this means +// we pad more on the right and bottom than on the top and left. +void getConvPoolOutParams(const Size& inp, const Size &kernel, + const Size &stride, const String &padMode, + Size& out) +{ + if (padMode == "VALID") + { + out.height = (inp.height - kernel.height + stride.height) / stride.height; + out.width = (inp.width- kernel.width + stride.width) / stride.width; + } + else if (padMode == "SAME") + { + out.height = (inp.height - 1 + stride.height) / stride.height; + out.width = (inp.width - 1 + stride.width) / stride.width; + } + else + { + CV_Error(Error::StsError, "Unsupported padding mode"); + } +} + +void getConvPoolPaddings(const Size& inp, const Size& out, + const Size &kernel, const Size &stride, + const String &padMode, Size &pad) +{ + if (padMode == "VALID") + { + pad = cv::Size(0,0); + } + else if (padMode == "SAME") + { + int Ph = std::max(0, (out.height - 1) * stride.height + kernel.height - inp.height); + int Pw = std::max(0, (out.width - 1) * stride.width + kernel.width - inp.width); + // For odd values of total padding, add more padding at the 'right' + // side of the given dimension. + pad = cv::Size(Pw / 2, Ph / 2); + } +} + +} +} diff --git a/modules/dnn/src/layers/layers_common.hpp b/modules/dnn/src/layers/layers_common.hpp new file mode 100644 index 0000000000..7f46369888 --- /dev/null +++ b/modules/dnn/src/layers/layers_common.hpp @@ -0,0 +1,87 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_LAYERS_LAYERS_COMMON_HPP__ +#define __OPENCV_DNN_LAYERS_LAYERS_COMMON_HPP__ +#include +#include + +namespace cv +{ +namespace dnn +{ + +void getConvolutionKernelParams(const LayerParams ¶ms, int &kernelH, int &kernelW, int &padH, int &padW, + int &strideH, int &strideW, int &dilationH, int &dilationW, cv::String& padMode); + +void getPoolingKernelParams(const LayerParams ¶ms, int &kernelH, int &kernelW, bool &globalPooling, + int &padH, int &padW, int &strideH, int &strideW, cv::String& padMode); + +void getConvPoolOutParams(const Size& inp, const Size &kernel, + const Size &stride, const String &padMode, + Size& out); + +void getConvPoolPaddings(const Size& inp, const Size& out, + const Size &kernel, const Size &stride, + const String &padMode, Size &pad); + +#if CV_SSE2 +#define CV_DNN_TRY_AVX2 1 + +void fastConv_avx2(const float* weights, size_t wstep, const float* bias, + const float* rowbuf, float* output, const int* outShape, + int blockSize, int vecsize, int vecsize_aligned, + const float* relu, bool initOutput); +void fastGEMM1T_avx2( const float* vec, const float* weights, + size_t wstep, const float* bias, + float* dst, int nvecs, int vecsize ); +void fastGEMM_avx2( const float* aptr, size_t astep, const float* bptr0, + size_t bstep, float* cptr, size_t cstep, + int ma, int na, int nb ); + +#else +#define CV_DNN_TRY_AVX2 0 +#endif + +} +} + +#endif diff --git a/modules/dnn/src/layers/lrn_layer.cpp b/modules/dnn/src/layers/lrn_layer.cpp new file mode 100644 index 0000000000..80b48c8864 --- /dev/null +++ b/modules/dnn/src/layers/lrn_layer.cpp @@ -0,0 +1,341 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/dnn/shape_utils.hpp" +#include "opencv2/core/hal/hal.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class LRNLayerImpl : public LRNLayer +{ +public: + LRNLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + type = -1; + String nrmType = params.get("norm_region", "ACROSS_CHANNELS"); + if (nrmType == "ACROSS_CHANNELS") + type = LRNLayer::CHANNEL_NRM; + else if (nrmType == "WITHIN_CHANNEL") + type = LRNLayer::SPATIAL_NRM; + else + CV_Error(Error::StsBadArg, "Unknown region type \"" + nrmType + "\""); + + size = params.get("local_size", 5); + if (size % 2 != 1 || size <= 0) + CV_Error(Error::StsBadArg, "LRN layer supports only positive odd values for local_size"); + + alpha = params.get("alpha", 1); + beta = params.get("beta", 0.75); + bias = params.get("bias", 1); + normBySize = params.get("norm_by_size", true); + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide(); + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + CV_Assert(inputs.size() == outputs.size()); + for (int i = 0; i < inputs.size(); i++) + { + CV_Assert(inputs[i]->dims == 4); + + Mat &src = *inputs[i]; + Mat &dst = outputs[i]; + + switch (type) + { + case CHANNEL_NRM: + channelNormalization(src, dst); + break; + case SPATIAL_NRM: + spatialNormalization(src, dst); + break; + default: + CV_Error(Error::StsNotImplemented, "Unimplemented mode of LRN layer"); + break; + } + } + } + + class ChannelLRN : public ParallelLoopBody + { + public: + ChannelLRN(const float* src, float* dst, int channels, int ksize, + float alpha1, float bias1, float beta1, + size_t planeSize, int nsamples, int nstripes) + { + src_ = src; dst_ = dst; + channels_ = channels; + ksize_ = ksize; + alpha1_ = alpha1; bias1_ = bias1; beta1_ = beta1; + planeSize_ = planeSize; nsamples_ = nsamples; nstripes_ = nstripes; + } + + void operator()(const Range& r) const + { + int nsamples = nsamples_, nstripes = nstripes_; + size_t planeSize = planeSize_, planeSize_n = planeSize * nsamples; + size_t elemsPerStripe = (planeSize_n + nstripes - 1)/nstripes; + size_t rstart = r.start*elemsPerStripe; + size_t rend = r.end == nstripes ? planeSize_n : r.end*elemsPerStripe; + rstart = std::min(rstart, planeSize_n); + rend = std::min(rend, planeSize_n); + float alpha1 = alpha1_, bias1 = bias1_, beta1 = beta1_; + int k, channels = channels_, ksize = ksize_; + + AutoBuffer buf_((channels + ksize*2 + 4)*2); + float* acc = (float*)buf_; + float* buf = acc + channels + ksize + 1; + for( k = 0; k <= ksize; k++ ) + buf[-k-1] = buf[channels + k] = 0.f; + + for( size_t ofs = rstart; ofs < rend; ) + { + int sampleIdx = (int)(ofs/planeSize); + if( sampleIdx >= nsamples ) + break; + size_t ofs0 = ofs - sampleIdx*planeSize; + size_t ofs1 = std::min(planeSize - ofs0, rend - ofs) + ofs; + const float* src = src_ + sampleIdx*planeSize*channels + ofs0; + float* dst = dst_ + sampleIdx*planeSize*channels + ofs0; + + for( ; ofs < ofs1; ofs++, src++, dst++ ) + { + for( k = 0; k < channels; k++ ) + buf[k] = src[k*planeSize]; + float s = 0; + for( k = 0; k < ksize; k++ ) + s += buf[k]*buf[k]; + for( k = 0; k < channels; k++ ) + { + float x1 = buf[k + ksize]; + float x0 = buf[k - ksize - 1]; + s = std::max(s + (x1 + x0)*(x1 - x0), 0.f); + acc[k] = (float)(alpha1*s + bias1); + } + + hal::log32f(acc, acc, channels); + for( k = 0; k < channels; k++ ) + acc[k] *= beta1; + hal::exp32f(acc, acc, channels); + + for( k = 0; k < channels; k++ ) + dst[k*planeSize] = buf[k]*acc[k]; + } + } + } + + const float* src_; + float* dst_; + float alpha1_, bias1_, beta1_; + size_t planeSize_; + int channels_, ksize_, nsamples_, nstripes_; + }; + + void channelNormalization(Mat &srcBlob, Mat &dstBlob) + { + int num = srcBlob.size[0]; + int channels = srcBlob.size[1]; + int ksize = (size - 1) / 2; + int sizeNormFactor = normBySize ? size : 1; + size_t planeSize = srcBlob.size[2]*srcBlob.size[3]; + + int nstripes = std::max(getNumThreads(), 1); + + ChannelLRN clrn(srcBlob.ptr(), dstBlob.ptr(), channels, + ksize, alpha/sizeNormFactor, bias, -beta, planeSize, num, nstripes); + parallel_for_(Range(0, nstripes), clrn, nstripes); + } + + void sqrBoxFilter_(const Mat &src, Mat &dst) + { + Mat srcRawWrapper(src.rows, src.cols, src.type(), src.data, src.step[0]); + cv::sqrBoxFilter(srcRawWrapper, dst, dst.depth(), Size(size, size), Point(-1, -1), false, BORDER_CONSTANT); + } + + void spatialNormalization(Mat &srcBlob, Mat &dstBlob) + { + int num = srcBlob.size[0]; + int channels = srcBlob.size[1]; + int sizeNormFactor = normBySize ? size*size : 1; + + Mat srcMat = srcBlob; + Mat dstMat = dstBlob; + + for (int n = 0; n < num; n++) + { + for (int cn = 0; cn < channels; cn++) + { + Mat src = getPlane(srcMat, n, cn); + Mat dst = getPlane(dstMat, n, cn); + + sqrBoxFilter_(src, dst); + + dst.convertTo(dst, dst.type(), alpha/sizeNormFactor, bias); + cv::pow(dst, beta, dst); + cv::divide(src, dst, dst); + } + } + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + float alphaSize = alpha; + if (normBySize) + alphaSize /= (type == CHANNEL_NRM ? size : size * size); + int width, height, channels, numImgs; + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + getCanonicalSize(inputBuffer, &width, &height, &channels, &numImgs); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Func padded_sq(name + "_padded_sq"); + Halide::Func sq("sq"); + sq(x, y, c, n) = inputBuffer(x, y, c, n) * inputBuffer(x, y, c, n); + + Halide::Func bounded = + Halide::BoundaryConditions::constant_exterior(sq, 0, 0, width, + 0, height, + 0, channels, + 0, numImgs); + padded_sq(x, y, c, n) = bounded(x, y, c, n); + + Halide::Expr base; + if (type == CHANNEL_NRM) + { + Halide::RDom r((1 - size) / 2, size); + base = alphaSize * sum(padded_sq(x, y, c + r, n)); + } + else // SPATIAL_NRM + { + Halide::RDom r((1 - size) / 2, size, (1 - size) / 2, size); + base = alphaSize * sum(padded_sq(x + r.x, y + r.y, c, n)); + } + base += static_cast(bias); + top(x, y, c, n) = inputBuffer(x, y, c, n) / pow(base, beta); + return Ptr(new HalideBackendNode({ padded_sq, top })); +#endif // HAVE_HALIDE + return Ptr(); + } + + virtual void applyHalideScheduler(Ptr& node, + const std::vector &inputs, + const std::vector &outputs, + int targetId) const + { +#ifdef HAVE_HALIDE + if (targetId != DNN_TARGET_CPU) + { + Layer::applyHalideScheduler(node, inputs, outputs, targetId); + return; + } + int outW, outH, outC, outN; + getCanonicalSize(outputs[0].size, &outW, &outH, &outC, &outN); + + Halide::Var x("x"), y("y"), c("c"), n("n"), yo("yo"), yi("yi"), tile("tile"); + Halide::Func& top = node.dynamicCast()->funcs[1]; + Halide::Func& padded_sq = node.dynamicCast()->funcs[0]; + + if (outW < 8 || outH <= 2) + return; + + top.reorder(x, c, y, n) + .split(y, yo, yi, 2) + .fuse(yo, n, tile) + .parallel(tile) + .unroll(yi) + .vectorize(x, 8); + padded_sq.store_at(top, tile) + .compute_at(top, yi); +#endif // HAVE_HALIDE + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + CV_Assert(inputs.size() > 0); + long flops = 0; + + for(int i = 0; i < inputs.size(); i++) + { + if (type == CHANNEL_NRM) + { + int channels = inputs[i][1]; + int ksize = (size - 1) / 2; + + flops += inputs[i][0]*(std::min(ksize, channels)*2*total(inputs[i], 2) + channels*4*total(inputs[i], 2)); + + if (ksize < channels) + { + flops += (size + 2*(channels - size))*total(inputs[i], 2); + } + } + else + { + flops += total(inputs[i])*(2*size*size + 2); + } + } + return flops; + } +}; + +Ptr LRNLayer::create(const LayerParams& params) +{ + return Ptr(new LRNLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/max_unpooling_layer.cpp b/modules/dnn/src/layers/max_unpooling_layer.cpp new file mode 100644 index 0000000000..70dc18d737 --- /dev/null +++ b/modules/dnn/src/layers/max_unpooling_layer.cpp @@ -0,0 +1,128 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Implementation of Batch Normalization layer. +*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class MaxUnpoolLayerImpl : public MaxUnpoolLayer +{ +public: + MaxUnpoolLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + poolKernel = Size(params.get("pool_k_w"), params.get("pool_k_h")); + poolPad = Size(params.get("pool_pad_w"), params.get("pool_pad_h")); + poolStride = Size(params.get("pool_stride_w"), params.get("pool_stride_h")); + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide() && + !poolPad.width && !poolPad.height; + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() == 2); + CV_Assert(total(inputs[0]) == total(inputs[1])); + + MatShape outShape = inputs[0]; + outShape[2] = (outShape[2] - 1) * poolStride.height + poolKernel.height - 2 * poolPad.height; + outShape[3] = (outShape[3] - 1) * poolStride.width + poolKernel.width - 2 * poolPad.width; + + outputs.clear(); + outputs.push_back(outShape); + + return false; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + CV_Assert(inputs.size() == 2); + Mat& input = *inputs[0]; + Mat& indices = *inputs[1]; + + CV_Assert(input.total() == indices.total()); + CV_Assert(input.size[0] == 1); + CV_Assert(input.isContinuous()); + + for(int i_n = 0; i_n < outputs.size(); i_n++) + { + Mat& outBlob = outputs[i_n]; + outBlob.setTo(0); + CV_Assert(input.size[1] == outBlob.size[1]); + int outPlaneTotal = outBlob.size[2]*outBlob.size[3]; + + for (int i_c = 0; i_c < input.size[1]; i_c++) + { + Mat outPlane = getPlane(outBlob, 0, i_c); + int wh_area = input.size[2]*input.size[3]; + const float* inptr = input.ptr(0, i_c); + const float* idxptr = indices.ptr(0, i_c); + float* outptr = outPlane.ptr(); + + for(int i_wh = 0; i_wh < wh_area; i_wh++) + { + int index = idxptr[i_wh]; + CV_Assert(0 <= index && index < outPlaneTotal); + outptr[index] = inptr[i_wh]; + } + } + } + } + + virtual Ptr initHalide(const std::vector > &input) + { +#ifdef HAVE_HALIDE + // Meaningless operation if false because if kernel > stride + // it is not deterministic and if kernel < stride we just + // skip a part of input data (you'd better change your model). + if (poolKernel.width != poolStride.width || + poolKernel.height != poolStride.height) + CV_Error(cv::Error::StsNotImplemented, + "Halide backend for maximum unpooling " + "is not support cases when kernel != stride"); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Buffer inputBuffer = halideBuffer(input[0]); + Halide::Buffer indices = halideBuffer(input[1]); + + Halide::Expr pooledX = x / poolKernel.width; + Halide::Expr pooledY = y / poolKernel.height; + + const int outW = inputBuffer.width() * poolKernel.width; + top(x, y, c, n) = select(y * outW + x == indices(pooledX, pooledY, c, n), + inputBuffer(pooledX, pooledY, c, n), 0.0f); + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } +}; + +Ptr MaxUnpoolLayer::create(const LayerParams& params) +{ + return Ptr(new MaxUnpoolLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/mvn_layer.cpp b/modules/dnn/src/layers/mvn_layer.cpp new file mode 100644 index 0000000000..e5bdf9ba78 --- /dev/null +++ b/modules/dnn/src/layers/mvn_layer.cpp @@ -0,0 +1,108 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class MVNLayerImpl : public MVNLayer +{ +public: + MVNLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + normVariance = params.get("normalize_variance", true); + acrossChannels = params.get("across_channels", false); + eps = params.get("eps", 1e-9); + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for (size_t inpIdx = 0; inpIdx < inputs.size(); inpIdx++) + { + Mat &inpBlob = *inputs[inpIdx]; + Mat &outBlob = outputs[inpIdx]; + + int splitDim = (acrossChannels) ? 1 : 2; + int i, newRows = 1; + for( i = 0; i < splitDim; i++ ) + newRows *= inpBlob.size[i]; + Mat inpMat = inpBlob.reshape(1, newRows); + Mat outMat = outBlob.reshape(1, newRows); + + Scalar mean, dev; + for ( i = 0; i < newRows; i++) + { + Mat inpRow = inpMat.row(i); + Mat outRow = outMat.row(i); + + cv::meanStdDev(inpRow, mean, (normVariance) ? dev : noArray()); + double alpha = (normVariance) ? 1/(eps + dev[0]) : 1; + inpRow.convertTo(outRow, outRow.type(), alpha, -mean[0] * alpha); + } + } + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + long flops = 0; + for(int i = 0; i < inputs.size(); i++) + { + flops += 6*total(inputs[i]) + 3*total(inputs[i], 0, normVariance ? 2 : 1); + } + return flops; + } +}; + +Ptr MVNLayer::create(const LayerParams& params) +{ + return Ptr(new MVNLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/normalize_bbox_layer.cpp b/modules/dnn/src/layers/normalize_bbox_layer.cpp new file mode 100644 index 0000000000..8299484fd2 --- /dev/null +++ b/modules/dnn/src/layers/normalize_bbox_layer.cpp @@ -0,0 +1,223 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" + +#include +#include + +namespace cv +{ +namespace dnn +{ + +namespace +{ + const std::string layerName = "NormalizeBBox"; +} + +class NormalizeBBoxLayerImpl : public NormalizeBBoxLayer +{ + float _eps; + bool _across_spatial; + bool _channel_shared; +public: + bool getParameterDict(const LayerParams ¶ms, + const std::string ¶meterName, + DictValue& result) + { + if (!params.has(parameterName)) + { + return false; + } + + result = params.get(parameterName); + return true; + } + + template + T getParameter(const LayerParams ¶ms, + const std::string ¶meterName, + const size_t &idx=0, + const bool required=true, + const T& defaultValue=T()) + { + DictValue dictValue; + bool success = getParameterDict(params, parameterName, dictValue); + if(!success) + { + if(required) + { + std::string message = layerName; + message += " layer parameter does not contain "; + message += parameterName; + message += " parameter."; + CV_Error(Error::StsBadArg, message); + } + else + { + return defaultValue; + } + } + return dictValue.get(idx); + } + + NormalizeBBoxLayerImpl(const LayerParams ¶ms) + { + _eps = getParameter(params, "eps", 0, false, 1e-10f); + _across_spatial = getParameter(params, "across_spatial"); + _channel_shared = getParameter(params, "channel_shared"); + setParamsFrom(params); + } + + void checkInputs(const std::vector &inputs) + { + CV_Assert(inputs.size() > 0); + CV_Assert(inputs[0]->dims == 4 && inputs[0]->type() == CV_32F); + for (size_t i = 1; i < inputs.size(); i++) + { + CV_Assert(inputs[i]->dims == 4 && inputs[i]->type() == CV_32F); + CV_Assert(inputs[i]->size == inputs[0]->size); + } + CV_Assert(inputs[0]->dims > 2); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + bool inplace = Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals); + size_t channels = inputs[0][1]; + size_t rows = inputs[0][2]; + size_t cols = inputs[0][3]; + size_t channelSize = rows * cols; + + internals.assign(1, shape(channels, channelSize)); + internals.push_back(shape(channels, 1)); + internals.push_back(shape(1, channelSize)); + + return inplace; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + checkInputs(inputs); + + Mat& buffer = internals[0], sumChannelMultiplier = internals[1], + sumSpatialMultiplier = internals[2]; + + sumChannelMultiplier.setTo(1.0); + sumSpatialMultiplier.setTo(1.0); + + const Mat& inp0 = *inputs[0]; + size_t num = inp0.size[0]; + size_t channels = inp0.size[1]; + size_t channelSize = inp0.size[2] * inp0.size[3]; + + Mat zeroBuffer(channels, channelSize, CV_32F, Scalar(0)); + Mat absDiff; + Mat scale = blobs[0]; + for (size_t j = 0; j < inputs.size(); j++) + { + for (size_t n = 0; n < num; ++n) + { + Mat src = Mat(channels, channelSize, CV_32F, inputs[j]->ptr(n)); + Mat dst = Mat(channels, channelSize, CV_32F, outputs[j].ptr(n)); + + buffer = src.mul(src); + + if (_across_spatial) + { + absdiff(buffer, zeroBuffer, absDiff); + + // add eps to avoid overflow + double absSum = sum(absDiff)[0] + _eps; + + float norm = sqrt(absSum); + dst = src / norm; + } + else + { + Mat norm(channelSize, 1, buffer.type()); // 1 x channelSize + + // (_channels x channelSize)T * _channels x 1 -> channelSize x 1 + gemm(buffer, sumChannelMultiplier, 1, norm, 0, norm, GEMM_1_T); + + // compute norm + pow(norm, 0.5f, norm); + + // scale the layer + // _channels x 1 * (channelSize x 1)T -> _channels x channelSize + gemm(sumChannelMultiplier, norm, 1, buffer, 0, buffer, GEMM_2_T); + + dst = src / buffer; + } + + // scale the output + if (_channel_shared) + { + // _scale: 1 x 1 + dst *= scale.at(0, 0); + } + else + { + // _scale: _channels x 1 + // _channels x 1 * 1 x channelSize -> _channels x channelSize + gemm(scale, sumSpatialMultiplier, 1, buffer, 0, buffer); + + dst = dst.mul(buffer); + } + } + } + } + +}; + + +Ptr NormalizeBBoxLayer::create(const LayerParams ¶ms) +{ + return Ptr(new NormalizeBBoxLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/padding_layer.cpp b/modules/dnn/src/layers/padding_layer.cpp new file mode 100644 index 0000000000..4e87426c3c --- /dev/null +++ b/modules/dnn/src/layers/padding_layer.cpp @@ -0,0 +1,131 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Implementation of padding layer, which adds paddings to input blob. +*/ + +#include "../precomp.hpp" +#include "op_halide.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class PaddingLayerImpl : public PaddingLayer +{ +public: + PaddingLayerImpl(const LayerParams ¶ms) + { + setParamsFrom(params); + paddingDim = params.get("padding_dim"); + padding = abs(params.get("padding")); + inputDims = params.get("input_dims", 0); + index = params.get("index", 0); + paddingValue = params.get("value", 0); + + if(paddingDim < 0 || padding < 0) + CV_Error(cv::Error::StsNotImplemented, "Negative padding and dim aren't supported"); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + outputs.clear(); + for(int i = 0; i < inputs.size(); i++) + { + MatShape shape = inputs[i]; + int dim = getPadDim(shape); + CV_Assert(dim < shape.size()); + + shape[dim] += padding; + outputs.push_back(shape); + } + + return false; + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide(); + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for(int i = 0; i < inputs.size(); i++) + { + outputs[i] = paddingValue; + const Mat& inp = *inputs[i]; + Mat& out = outputs[i]; + int dims = inp.dims; + MatShape inShape(inp.size.p, inp.size.p + dims); + MatShape outShape(out.size.p, out.size.p + dims); + int dim = getPadDim(inShape); + + int actualIndex = index; + if(index == 0) + actualIndex = inShape[dim]; + + std::vector > srcDstRanges; + srcDstRanges.push_back(std::make_pair(Range(0, actualIndex), Range(0, actualIndex))); + srcDstRanges.push_back(std::make_pair(Range(actualIndex, inShape[dim]), + Range(actualIndex + padding, outShape[dim]))); + + std::vector srcRanges(dims, Range::all()), dstRanges = srcRanges; + + for(int j = 0; j < srcDstRanges.size(); j++) + { + if(!srcDstRanges[j].first.empty()) + { + srcRanges[dim] = srcDstRanges[j].first; + dstRanges[dim] = srcDstRanges[j].second; + Mat dst = out(&dstRanges[0]); + Mat src = inp(&srcRanges[0]).clone(); + src.copyTo(dst); + } + } + } + } + + int getPadDim(const MatShape& shape) const + { + return inputDims > 0 && (int)shape.size() > inputDims ? paddingDim + 1 : paddingDim; + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + int inW, inH, inC, inN; + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + getCanonicalSize(inputBuffer, &inW, &inH, &inC, &inN); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Func padded = + Halide::BoundaryConditions::constant_exterior(inputBuffer, paddingValue); + top(x, y, c, n) = padded(x, y, c, n); + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + + int paddingDim, padding, inputDims, index; + float paddingValue; +}; + +Ptr PaddingLayer::create(const LayerParams ¶ms) +{ + return Ptr(new PaddingLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/permute_layer.cpp b/modules/dnn/src/layers/permute_layer.cpp new file mode 100644 index 0000000000..202359f451 --- /dev/null +++ b/modules/dnn/src/layers/permute_layer.cpp @@ -0,0 +1,243 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include +#include + +namespace cv +{ +namespace dnn +{ +class PermuteLayerImpl : public PermuteLayer +{ +public: + void checkCurrentOrder(int currentOrder) + { + if(currentOrder < 0 || currentOrder > 3) + { + CV_Error( + Error::StsBadArg, + "Orders of dimensions in Permute layer parameter" + "must be in [0...3] interval"); + } + + if(std::find(_order.begin(), _order.end(), currentOrder) != _order.end()) + { + CV_Error(Error::StsBadArg, + "Permute layer parameter contains duplicated orders."); + } + } + + void checkNeedForPermutation() + { + _needsPermute = false; + for (size_t i = 0; i < _numAxes; ++i) + { + if (_order[i] != i) + { + _needsPermute = true; + break; + } + } + } + + PermuteLayerImpl(const LayerParams ¶ms) + { + if (!params.has("order")) + { + _needsPermute = false; + return; + } + + DictValue paramOrder = params.get("order"); + if(paramOrder.size() > 4) + { + CV_Error( + Error::StsBadArg, + "Too many (> 4) orders of dimensions in Permute layer"); + } + + _numAxes = paramOrder.size(); + + for (size_t i = 0; i < _numAxes; i++) + { + int currentOrder = paramOrder.get(i); + checkCurrentOrder(currentOrder); + _order.push_back(currentOrder); + } + + setParamsFrom(params); + checkNeedForPermutation(); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + if(!_needsPermute) + return true; + + CV_Assert(inputs.size() > 0); + CV_Assert((int)_numAxes == inputs[0].size()); + + MatShape shapeBefore = inputs[0], shapeAfter; + for (size_t i = 0; i < _numAxes; i++) + { + shapeAfter.push_back(shapeBefore[_order[i]]); + } + + outputs.clear(); + + for (size_t i = 0; i < inputs.size(); i++) + { + CV_Assert(inputs[i][2] == shapeBefore[2] && inputs[i][3] == shapeBefore[3]); + CV_Assert(total(inputs[i]) == total(shapeAfter)); + outputs.push_back(shapeAfter); + } + + return false; + } + + void computeStrides(const MatShape &shapeBefore, const MatShape &shapeAfter) + { + _oldStride.resize(_numAxes); + _newStride.resize(_numAxes); + + _oldStride[_numAxes - 1] = 1; + _newStride[_numAxes - 1] = 1; + + for(int i = _numAxes - 2; i >= 0; i--) + { + _oldStride[i] = _oldStride[i + 1] * shapeBefore[i + 1]; + _newStride[i] = _newStride[i + 1] * shapeAfter[i + 1]; + } + + _count = _oldStride[0] * shapeBefore[0]; + } + + void finalize(const std::vector &inputs, std::vector &outputs) + { + if(!_needsPermute) + { + return; + } + + CV_Assert(inputs.size() > 0); + const Mat& inp0 = *inputs[0]; + CV_Assert((int)_numAxes == inp0.dims); + + computeStrides(shape(*inputs[0]), shape(outputs[0])); + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + size_t k, ninputs = inputs.size(); + if(!_needsPermute) + { + for (k = 0; k < ninputs; k++) + outputs[k] = *inputs[k]; + } + else + { + size_t i, j, count = _count, numAxes = _numAxes; + const size_t* newStride = &_newStride[0]; + const size_t* oldStride = &_oldStride[0]; + const size_t* order = &_order[0]; + + for (k = 0; k < ninputs; k++) + { + const Mat& inp = *inputs[k]; + Mat& out = outputs[k]; + + CV_Assert(inp.dims == numAxes && inp.size == inputs[0]->size); + CV_Assert(out.dims == numAxes && out.size == outputs[0].size); + +// for( i = 0; i < numAxes; i++ ) +// { +// CV_Assert(inp.size[i] == _oldDimensionSize[i]); +// CV_Assert(out.size[i] == _newDimensionSize[i]); +// } + + CV_Assert(inp.isContinuous() && out.isContinuous()); + CV_Assert(inp.type() == CV_32F && out.type() == CV_32F); + + const float *srcData = inp.ptr(); + float *dstData = out.ptr(); + + for (i = 0; i < count; ++i) + { + size_t oldPosition = 0; + size_t newPosition = i; + + for (j = 0; j < numAxes; ++j) + { + oldPosition += (newPosition / newStride[j]) * oldStride[order[j]]; + newPosition %= newStride[j]; + } + dstData[i] = srcData[oldPosition]; + } + } + } + } + + size_t _count; + std::vector _order; + + std::vector _oldDimensionSize; + std::vector _newDimensionSize; + + std::vector _oldStride; + std::vector _newStride; + bool _needsPermute; + + size_t _numAxes; +}; + +Ptr PermuteLayer::create(const LayerParams ¶ms) +{ + return Ptr(new PermuteLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/pooling_layer.cpp b/modules/dnn/src/layers/pooling_layer.cpp new file mode 100644 index 0000000000..25fe46889d --- /dev/null +++ b/modules/dnn/src/layers/pooling_layer.cpp @@ -0,0 +1,566 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "opencv2/core/hal/intrin.hpp" +#include "op_halide.hpp" +#include +#include +using std::max; +using std::min; + +namespace cv +{ +namespace dnn +{ + +//TODO: add ceil_mode param +class PoolingLayerImpl : public PoolingLayer +{ +public: + PoolingLayerImpl(const LayerParams& params) + { + type = PoolingLayer::MAX; + computeMaxIdx = true; + + if (params.has("pool")) + { + String pool = params.get("pool").toLowerCase(); + if (pool == "max") + type = PoolingLayer::MAX; + else if (pool == "ave") + type = PoolingLayer::AVE; + else if (pool == "stochastic") + type = PoolingLayer::STOCHASTIC; + else + CV_Error(Error::StsBadArg, "Unknown pooling type \"" + pool + "\""); + } + + getPoolingKernelParams(params, kernel.height, kernel.width, globalPooling, + pad.height, pad.width, stride.height, stride.width, padMode); + setParamsFrom(params); + } + + void finalize(const std::vector &inputs, std::vector &outputs) + { + CV_Assert(inputs.size() == 1); + + cv::Size inp(inputs[0]->size[3], inputs[0]->size[2]), + out(outputs[0].size[3], outputs[0].size[2]); + + if(globalPooling) + { + kernel = inp; + } + + getConvPoolPaddings(inp, out, kernel, stride, padMode, pad); + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide() && + (type == PoolingLayer::MAX || + type == PoolingLayer::AVE && !pad.width && !pad.height); + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for (size_t ii = 0; ii < inputs.size(); ii++) + { + switch (type) + { + case MAX: + maxPooling(*inputs[ii], outputs[2 * ii], outputs[2 * ii + 1]); + break; + case AVE: + avePooling(*inputs[ii], outputs[ii]); + break; + default: + CV_Error(Error::StsNotImplemented, "Not implemented"); + break; + } + } + } + + virtual Ptr initHalide(const std::vector > &inputs) + { + if (type == PoolingLayer::MAX) + return initMaxPoolingHalide(inputs); + else if (type == PoolingLayer::AVE) + return initAvePoolingHalide(inputs); + else + return Ptr(); + } + + class MaxPoolingInvoker : public ParallelLoopBody + { + public: + const Mat* src_; + Mat *dst_, *mask_; + Size kernel_, stride_, pad_; + int nstripes_; + bool computeMaxIdx_; + + MaxPoolingInvoker(const Mat& src, Mat& dst, Mat& mask, Size kernel, + Size stride, Size pad, int nstripes, bool computeMaxIdx) + { + src_ = &src; + dst_ = &dst; + mask_ = &mask; + kernel_ = kernel; + stride_ = stride; + pad_ = pad; + nstripes_ = nstripes; + computeMaxIdx_ = computeMaxIdx; + + CV_Assert(src.isContinuous() && dst.isContinuous() && + src.type() == CV_32F && src.type() == dst.type() && + mask.type() == src.type() && src.dims == 4 && dst.dims == 4 && + src.size[0] == dst.size[0] && src.size[1] == dst.size[1] && + mask.size == dst.size); + } + + void operator()(const Range& r) const + { + int nimgs = dst_->size[0], channels = dst_->size[1]; + int width = dst_->size[3], height = dst_->size[2]; + int inp_width = src_->size[3], inp_height = src_->size[2]; + size_t total = dst_->total(); + size_t stripeSize = (total + nstripes_ - 1)/nstripes_; + size_t stripeStart = r.start*stripeSize; + size_t stripeEnd = std::min(r.end*stripeSize, total); + size_t ofs = stripeStart; + int x0 = (int)(ofs % width); + ofs /= width; + int y0 = (int)(ofs % height); + ofs /= height; + int c = (int)(ofs % channels); + int n = (int)(ofs / channels); + const float *srcData = src_->ptr(n, c); + float *dstData = dst_->ptr(n, c, y0) + x0; + float *dstMaskData = mask_->ptr(n, c, y0) + x0; + int kernel_w = kernel_.width, kernel_h = kernel_.height; + int pad_w = pad_.width, pad_h = pad_.height; + int stride_w = stride_.width, stride_h = stride_.height; + bool compMaxIdx = computeMaxIdx_; + #if CV_SIMD128 + v_float32x4 idx00(0.f, (float)stride_w, (float)(stride_w*2), (float)(stride_w*3)); + v_float32x4 ones = v_setall_f32(1.f); + v_float32x4 delta = v_setall_f32((float)(inp_width - kernel_w)); + #endif + + for( ofs = stripeStart; ofs < stripeEnd; ofs++ ) + { + int ystart = y0 * stride_h - pad_h; + int xstart = x0 * stride_w - pad_w; + int yend = min(ystart + kernel_h, inp_height); + int xend = min(xstart + kernel_w, inp_width); + ystart = max(ystart, 0); + xstart = max(xstart, 0); + float max_val = -FLT_MAX; + int max_index = -1; + + #if CV_SIMD128 + if( xstart > 0 && (x0 + 7) * stride_w - pad_w + kernel_w < inp_width ) + { + if( compMaxIdx ) + { + v_float32x4 max_val0 = v_setall_f32(max_val); + v_float32x4 max_val1 = max_val0; + v_float32x4 max_idx0 = v_setall_f32(-1.f); + v_float32x4 max_idx1 = max_idx0; + int index0 = ystart * inp_width + xstart; + v_float32x4 idx0 = idx00 + v_setall_f32((float)index0); + v_float32x4 idx1 = idx0 + v_setall_f32((float)(stride_w*4)); + + for (int y = ystart; y < yend; ++y) + { + for (int x = xstart; x < xend; ++x, idx0 += ones, idx1 += ones) + { + const int index = y * inp_width + x; + v_float32x4 v0(srcData[index], srcData[index + stride_w], + srcData[index + stride_w*2], srcData[index + stride_w*3]); + v_float32x4 v1(srcData[index + stride_w*4], srcData[index + stride_w*5], + srcData[index + stride_w*6], srcData[index + stride_w*7]); + max_idx0 = v_select(v0 > max_val0, idx0, max_idx0); + max_idx1 = v_select(v1 > max_val1, idx1, max_idx1); + max_val0 = v_max(max_val0, v0); + max_val1 = v_max(max_val1, v1); + } + idx0 += delta; + idx1 += delta; + } + v_store(dstData, max_val0); + v_store(dstData + 4, max_val1); + v_store(dstMaskData, max_idx0); + v_store(dstMaskData + 4, max_idx1); + ofs += 7; + dstData += 8; + dstMaskData += 8; + x0 += 7; + } + else + { + v_float32x4 max_val0 = v_setall_f32(max_val); + v_float32x4 max_val1 = max_val0; + + for (int y = ystart; y < yend; ++y) + { + for (int x = xstart; x < xend; ++x) + { + const int index = y * inp_width + x; + v_float32x4 v0(srcData[index], srcData[index + stride_w], + srcData[index + stride_w*2], srcData[index + stride_w*3]); + v_float32x4 v1(srcData[index + stride_w*4], srcData[index + stride_w*5], + srcData[index + stride_w*6], srcData[index + stride_w*7]); + max_val0 = v_max(max_val0, v0); + max_val1 = v_max(max_val1, v1); + } + } + v_store(dstData, max_val0); + v_store(dstData + 4, max_val1); + ofs += 7; + dstData += 8; + x0 += 7; + } + } + else + #endif + { + if( compMaxIdx ) + { + for (int y = ystart; y < yend; ++y) + for (int x = xstart; x < xend; ++x) + { + const int index = y * inp_width + x; + float val = srcData[index]; + if (val > max_val) + { + max_val = val; + max_index = index; + } + } + + *dstData++ = max_val; + *dstMaskData++ = max_index; + } + else + { + for (int y = ystart; y < yend; ++y) + for (int x = xstart; x < xend; ++x) + { + const int index = y * inp_width + x; + float val = srcData[index]; + max_val = std::max(max_val, val); + } + + *dstData++ = max_val; + } + } + + if( ++x0 >= width ) + { + x0 = 0; + if( ++y0 >= height ) + { + y0 = 0; + if( ++c >= channels ) + { + c = 0; + if( ++n >= nimgs ) + break; + } + srcData = src_->ptr(n, c); + } + } + } + } + }; + + void maxPooling(Mat &src, Mat &dst, Mat &mask) + { + const int nstripes = getNumThreads(); + MaxPoolingInvoker mp(src, dst, mask, kernel, stride, pad, nstripes, computeMaxIdx); + parallel_for_(Range(0, nstripes), mp, nstripes); + } + + void avePooling(Mat &src, Mat &dst) + { + Size inp(src.size[3], src.size[2]), + out(dst.size[3], dst.size[2]); + for (int n = 0; n < src.size[0]; ++n) + { + for (int c = 0; c < src.size[1]; ++c) + { + const float *srcData = src.ptr(n, c); + float *dstData = dst.ptr(n, c); + + for (int ph = 0; ph < out.height; ++ph) + { + for (int pw = 0; pw < out.width; ++pw) + { + int hstart = ph * stride.height - pad.height; + int wstart = pw * stride.width - pad.width; + int hend = min(hstart + kernel.height, inp.height + pad.height); + int wend = min(wstart + kernel.width, inp.width + pad.width); + int poolSize = (hend - hstart) * (wend - wstart); + hstart = max(hstart, 0); + wstart = max(wstart, 0); + hend = min(hend, inp.height); + wend = min(wend, inp.width); + + dstData[ph * out.width + pw] = 0.f; + + for (int h = hstart; h < hend; ++h) + for (int w = wstart; w < wend; ++w) + dstData[ph * out.width + pw] += srcData[h * inp.width + w]; + + dstData[ph * out.width + pw] /= poolSize; + } + } + } + } + } + + virtual Ptr initMaxPoolingHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + const int inWidth = inputBuffer.width(); + const int inHeight = inputBuffer.height(); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::RDom r(0, kernel.width, 0, kernel.height); + Halide::Expr kx, ky; + if (pad.width || pad.height) + { + kx = clamp(x * stride.width + r.x - pad.width, 0, inWidth - 1); + ky = clamp(y * stride.height + r.y - pad.height, 0, inHeight - 1); + } + else + { + kx = min(x * stride.width + r.x, inWidth - 1); + ky = min(y * stride.height + r.y, inHeight - 1); + } + + // Halide::argmax returns tuple (r.x, r.y, max). + Halide::Tuple res = argmax(inputBuffer(kx, ky, c, n)); + + // Compute offset from argmax in range [0, kernel_size). + Halide::Expr max_index; + if (pad.width || pad.height) + { + max_index = clamp(y * stride.height + res[1] - pad.height, + 0, inHeight - 1) * inWidth + + clamp(x * stride.width + res[0] - pad.width, + 0, inWidth - 1); + } + else + { + max_index = min(y * stride.height + res[1], inHeight - 1) * inWidth + + min(x * stride.width + res[0], inWidth - 1); + } + top(x, y, c, n) = { res[2], Halide::cast(max_index) }; + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + + virtual Ptr initAvePoolingHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + + const int inW = inputBuffer.width(), inH = inputBuffer.height(); + if ((inW - kernel.width) % stride.width || (inH - kernel.height) % stride.height) + { + CV_Error(cv::Error::StsNotImplemented, + "Halide backend for average pooling with partial " + "kernels is not implemented"); + } + + const float norm = 1.0f / (kernel.width * kernel.height); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::RDom r(0, kernel.width, 0, kernel.height); + top(x, y, c, n) = sum( + inputBuffer(x * stride.width + r.x, + y * stride.height + r.y, c, n)) * norm; + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + + virtual void applyHalideScheduler(Ptr& node, + const std::vector &inputs, + const std::vector &outputs, + int targetId) const + { +#ifdef HAVE_HALIDE + if (targetId != DNN_TARGET_CPU) + { + Layer::applyHalideScheduler(node, inputs, outputs, targetId); + return; + } + Halide::Var x("x"), y("y"), c("c"), n("n"), tile("tile"), + xi("xi"), yi("yi"), ci("ci"), xo("xo"), yo("yo"), co("co"); + Halide::Func& top = node.dynamicCast()->funcs.back(); + + int outW, outH, outC, outN; + getCanonicalSize(outputs[0].size, &outW, &outH, &outC, &outN); + + if (outW < 8 || outH < 8) + { + if (outC > 8) + top.split(c, co, ci, 8) + .fuse(x, y, tile).fuse(co, tile, tile).fuse(n, tile, tile) + .parallel(tile) + .vectorize(ci); + else + { + top.fuse(y, c, tile).fuse(n, tile, tile) + .parallel(tile); + if (outW > 1) + top.vectorize(x); + } + } + else + { + if (outC > 8) + top.split(x, xo, xi, 8).split(y, yo, yi, 8).split(c, co, ci, 8) + .fuse(xo, yo, tile).fuse(co, tile, tile).fuse(n, tile, tile) + .parallel(tile) + .vectorize(xi); + else + top.split(x, xo, xi, 8).split(y, yo, yi, 8) + .fuse(xo, yo, tile).fuse(c, tile, tile).fuse(n, tile, tile) + .parallel(tile) + .vectorize(xi); + } +#endif // HAVE_HALIDE + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() != 0); + Size in(inputs[0][3], inputs[0][2]), out; + + if (globalPooling) + { + out.height = 1; + out.width = 1; + } + else if (padMode.empty()) + { + //Yeah, something strange Caffe scheme-) + out.height = static_cast(ceil(static_cast(in.height + 2 * pad.height - + kernel.height) / stride.height)) + 1; + out.width = static_cast(ceil(static_cast(in.width + 2 * pad.width - + kernel.width) / stride.width)) + 1; + + if (pad.height || pad.width) + { + // If we have padding, ensure that the last pooling starts strictly + // inside the image (instead of at the padding); otherwise clip the last. + if ((out.height - 1) * stride.height >= in.height + pad.height) + --out.height; + if ((out.width - 1) * stride.width >= in.width + pad.width) + --out.width; + CV_Assert((out.height - 1) * stride.height < in.height + pad.height); + CV_Assert((out.width - 1) * stride.width < in.width + pad.width); + } + } + else + { + getConvPoolOutParams(in, kernel, stride, + padMode, out); + } + + outputs.resize(type == MAX ? 2 * inputs.size() : inputs.size()); + for (size_t i = 0; i < inputs.size(); i++) + { + size_t index = type == MAX ? 2*i : i; + int dims[] = {inputs[i][0], inputs[i][1], out.height, out.width}; + outputs[index] = shape(dims); + + if (type == MAX) + outputs[index + 1] = shape(dims); + } + + return false; + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)inputs; // suppress unused variable warning + long flops = 0; + + for(int i = 0; i < outputs.size(); i++) + { + if (type == MAX) + { + if (i%2 == 0) + flops += total(outputs[i])*kernel.area(); + } + else + { + flops += total(outputs[i])*(kernel.area() + 1); + } + } + return flops; + } +}; + +Ptr PoolingLayer::create(const LayerParams& params) +{ + return Ptr(new PoolingLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/prior_box_layer.cpp b/modules/dnn/src/layers/prior_box_layer.cpp new file mode 100644 index 0000000000..aee04e2801 --- /dev/null +++ b/modules/dnn/src/layers/prior_box_layer.cpp @@ -0,0 +1,379 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include +#include +#include + +namespace cv +{ +namespace dnn +{ + +class PriorBoxLayerImpl : public PriorBoxLayer +{ +public: + bool getParameterDict(const LayerParams ¶ms, + const std::string ¶meterName, + DictValue& result) + { + if (!params.has(parameterName)) + { + return false; + } + + result = params.get(parameterName); + return true; + } + + template + T getParameter(const LayerParams ¶ms, + const std::string ¶meterName, + const size_t &idx=0, + const bool required=true, + const T& defaultValue=T()) + { + DictValue dictValue; + bool success = getParameterDict(params, parameterName, dictValue); + if(!success) + { + if(required) + { + std::string message = _layerName; + message += " layer parameter does not contain "; + message += parameterName; + message += " parameter."; + CV_Error(Error::StsBadArg, message); + } + else + { + return defaultValue; + } + } + return dictValue.get(idx); + } + + void getAspectRatios(const LayerParams ¶ms) + { + DictValue aspectRatioParameter; + bool aspectRatioRetieved = getParameterDict(params, "aspect_ratio", aspectRatioParameter); + CV_Assert(aspectRatioRetieved); + + for (int i = 0; i < aspectRatioParameter.size(); ++i) + { + float aspectRatio = aspectRatioParameter.get(i); + bool alreadyExists = false; + + for (size_t j = 0; j < _aspectRatios.size(); ++j) + { + if (fabs(aspectRatio - _aspectRatios[j]) < 1e-6) + { + alreadyExists = true; + break; + } + } + if (!alreadyExists) + { + _aspectRatios.push_back(aspectRatio); + if (_flip) + { + _aspectRatios.push_back(1./aspectRatio); + } + } + } + } + + void getVariance(const LayerParams ¶ms) + { + DictValue varianceParameter; + bool varianceParameterRetrieved = getParameterDict(params, "variance", varianceParameter); + CV_Assert(varianceParameterRetrieved); + + int varianceSize = varianceParameter.size(); + if (varianceSize > 1) + { + // Must and only provide 4 variance. + CV_Assert(varianceSize == 4); + + for (int i = 0; i < varianceSize; ++i) + { + float variance = varianceParameter.get(i); + CV_Assert(variance > 0); + _variance.push_back(variance); + } + } + else + { + if (varianceSize == 1) + { + float variance = varianceParameter.get(0); + CV_Assert(variance > 0); + _variance.push_back(variance); + } + else + { + // Set default to 0.1. + _variance.push_back(0.1f); + } + } + } + + PriorBoxLayerImpl(const LayerParams ¶ms) + { + setParamsFrom(params); + _minSize = getParameter(params, "min_size"); + CV_Assert(_minSize > 0); + + _flip = getParameter(params, "flip"); + _clip = getParameter(params, "clip"); + + _aspectRatios.clear(); + _aspectRatios.push_back(1.); + + getAspectRatios(params); + getVariance(params); + + _numPriors = _aspectRatios.size(); + + _maxSize = -1; + if (params.has("max_size")) + { + _maxSize = params.get("max_size").get(0); + CV_Assert(_maxSize > _minSize); + + _numPriors += 1; + } + + if (params.has("step_h") || params.has("step_w")) { + CV_Assert(!params.has("step")); + _stepY = getParameter(params, "step_h"); + CV_Assert(_stepY > 0.); + _stepX = getParameter(params, "step_w"); + CV_Assert(_stepX > 0.); + } else if (params.has("step")) { + const float step = getParameter(params, "step"); + CV_Assert(step > 0); + _stepY = step; + _stepX = step; + } else { + _stepY = 0; + _stepX = 0; + } + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() == 2); + + int layerHeight = inputs[0][2]; + int layerWidth = inputs[0][3]; + + // Since all images in a batch has same height and width, we only need to + // generate one set of priors which can be shared across all images. + size_t outNum = 1; + // 2 channels. First channel stores the mean of each prior coordinate. + // Second channel stores the variance of each prior coordinate. + size_t outChannels = 2; + + outputs.resize(1, shape(outNum, outChannels, + layerHeight * layerWidth * _numPriors * 4)); + + return false; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + int _layerWidth = inputs[0]->size[3]; + int _layerHeight = inputs[0]->size[2]; + + int _imageWidth = inputs[1]->size[3]; + int _imageHeight = inputs[1]->size[2]; + + float stepX, stepY; + if (_stepX == 0 || _stepY == 0) { + stepX = static_cast(_imageWidth) / _layerWidth; + stepY = static_cast(_imageHeight) / _layerHeight; + } else { + stepX = _stepX; + stepY = _stepY; + } + + int _outChannelSize = _layerHeight * _layerWidth * _numPriors * 4; + + float* outputPtr = outputs[0].ptr(); + + // first prior: aspect_ratio = 1, size = min_size + int idx = 0; + for (size_t h = 0; h < _layerHeight; ++h) + { + for (size_t w = 0; w < _layerWidth; ++w) + { + _boxWidth = _boxHeight = _minSize; + + float center_x = (w + 0.5) * stepX; + float center_y = (h + 0.5) * stepY; + // xmin + outputPtr[idx++] = (center_x - _boxWidth / 2.) / _imageWidth; + // ymin + outputPtr[idx++] = (center_y - _boxHeight / 2.) / _imageHeight; + // xmax + outputPtr[idx++] = (center_x + _boxWidth / 2.) / _imageWidth; + // ymax + outputPtr[idx++] = (center_y + _boxHeight / 2.) / _imageHeight; + + if (_maxSize > 0) + { + // second prior: aspect_ratio = 1, size = sqrt(min_size * max_size) + _boxWidth = _boxHeight = sqrt(_minSize * _maxSize); + // xmin + outputPtr[idx++] = (center_x - _boxWidth / 2.) / _imageWidth; + // ymin + outputPtr[idx++] = (center_y - _boxHeight / 2.) / _imageHeight; + // xmax + outputPtr[idx++] = (center_x + _boxWidth / 2.) / _imageWidth; + // ymax + outputPtr[idx++] = (center_y + _boxHeight / 2.) / _imageHeight; + } + + // rest of priors + for (size_t r = 0; r < _aspectRatios.size(); ++r) + { + float ar = _aspectRatios[r]; + if (fabs(ar - 1.) < 1e-6) + { + continue; + } + _boxWidth = _minSize * sqrt(ar); + _boxHeight = _minSize / sqrt(ar); + // xmin + outputPtr[idx++] = (center_x - _boxWidth / 2.) / _imageWidth; + // ymin + outputPtr[idx++] = (center_y - _boxHeight / 2.) / _imageHeight; + // xmax + outputPtr[idx++] = (center_x + _boxWidth / 2.) / _imageWidth; + // ymax + outputPtr[idx++] = (center_y + _boxHeight / 2.) / _imageHeight; + } + } + } + // clip the prior's coordidate such that it is within [0, 1] + if (_clip) + { + for (size_t d = 0; d < _outChannelSize; ++d) + { + outputPtr[d] = std::min(std::max(outputPtr[d], 0.), 1.); + } + } + // set the variance. + outputPtr = outputs[0].ptr(0, 1); + if(_variance.size() == 1) + { + Mat secondChannel(outputs[0].size[2], outputs[0].size[3], CV_32F, outputPtr); + secondChannel.setTo(Scalar(_variance[0])); + } + else + { + int count = 0; + for (size_t h = 0; h < _layerHeight; ++h) + { + for (size_t w = 0; w < _layerWidth; ++w) + { + for (size_t i = 0; i < _numPriors; ++i) + { + for (int j = 0; j < 4; ++j) + { + outputPtr[count] = _variance[j]; + ++count; + } + } + } + } + } + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + long flops = 0; + + for (int i = 0; i < inputs.size(); i++) + { + flops += total(inputs[i], 2) * _numPriors * 4; + } + + return flops; + } + + float _minSize; + float _maxSize; + + float _boxWidth; + float _boxHeight; + + float _stepX, _stepY; + + std::vector _aspectRatios; + std::vector _variance; + + bool _flip; + bool _clip; + + size_t _numPriors; + + static const size_t _numAxes = 4; + static const std::string _layerName; +}; + +const std::string PriorBoxLayerImpl::_layerName = std::string("PriorBox"); + +Ptr PriorBoxLayer::create(const LayerParams ¶ms) +{ + return Ptr(new PriorBoxLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/recurrent_layers.cpp b/modules/dnn/src/layers/recurrent_layers.cpp new file mode 100644 index 0000000000..aa3d0df912 --- /dev/null +++ b/modules/dnn/src/layers/recurrent_layers.cpp @@ -0,0 +1,443 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include +#include +#include +#include + +namespace cv +{ +namespace dnn +{ + +template +static void tanh(const Mat &src, Mat &dst) +{ + MatConstIterator_ itSrc = src.begin(); + MatIterator_ itDst = dst.begin(); + + for (; itSrc != src.end(); itSrc++, itDst++) + *itDst = std::tanh(*itSrc); +} + +//TODO: make utils method +static void tanh(const Mat &src, Mat &dst) +{ + dst.create(src.dims, (const int*)src.size, src.type()); + + if (src.type() == CV_32F) + tanh(src, dst); + else if (src.type() == CV_64F) + tanh(src, dst); + else + CV_Error(Error::StsUnsupportedFormat, "Function supports only floating point types"); +} + +static void sigmoid(const Mat &src, Mat &dst) +{ + cv::exp(-src, dst); + cv::pow(1 + dst, -1, dst); +} + +class LSTMLayerImpl : public LSTMLayer +{ + int numTimeStamps, numSamples; + bool allocated; + + MatShape outTailShape; //shape of single output sample + MatShape outTsShape; //shape of N output samples + + bool useTimestampDim; + bool produceCellOutput; + +public: + + LSTMLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + type = "LSTM"; + useTimestampDim = true; + produceCellOutput = false; + allocated = false; + outTailShape.clear(); + } + + void setUseTimstampsDim(bool use) + { + CV_Assert(!allocated); + useTimestampDim = use; + } + + void setProduceCellOutput(bool produce) + { + CV_Assert(!allocated); + produceCellOutput = produce; + } + + void setOutShape(const MatShape &outTailShape_) + { + CV_Assert(!allocated || total(outTailShape) == total(outTailShape_)); + outTailShape = outTailShape_; + } + + void setWeights(const Mat &Wh, const Mat &Wx, const Mat &bias) + { + CV_Assert(Wh.dims == 2 && Wx.dims == 2); + CV_Assert(Wh.rows == Wx.rows); + CV_Assert(Wh.rows == 4*Wh.cols); + CV_Assert(Wh.rows == (int)bias.total()); + CV_Assert(Wh.type() == Wx.type() && Wx.type() == bias.type()); + + blobs.resize(3); + blobs[0] = Mat(Wh.clone()); + blobs[1] = Mat(Wx.clone()); + blobs[2] = Mat(bias.clone()).reshape(1, 1); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(blobs.size() == 3); + CV_Assert(inputs.size() == 1); + const MatShape& inp0 = inputs[0]; + + const Mat &Wh = blobs[0], &Wx = blobs[1]; + int _numOut = Wh.size[1]; + int _numInp = Wx.size[1]; + MatShape outTailShape_(outTailShape), outResShape; + + if (!outTailShape_.empty()) + CV_Assert(total(outTailShape_) == _numOut); + else + outTailShape_.assign(1, _numOut); + + int _numTimeStamps, _numSamples; + if (useTimestampDim) + { + CV_Assert(inp0.size() >= 2 && total(inp0, 2) == _numInp); + _numTimeStamps = inp0[0]; + _numSamples = inp0[1]; + outResShape.push_back(_numTimeStamps); + } + else + { + CV_Assert(inp0.size() >= 2 && total(inp0, 1) == _numInp); + _numTimeStamps = 1; + _numSamples = inp0[0]; + } + + outResShape.push_back(_numSamples); + outResShape.insert(outResShape.end(), outTailShape_.begin(), outTailShape_.end()); + + size_t noutputs = produceCellOutput ? 2 : 1; + outputs.assign(noutputs, outResShape); + + internals.assign(1, shape(_numSamples, _numOut)); // hInternal + internals.push_back(shape(_numSamples, _numOut)); // cInternal + internals.push_back(shape(_numSamples, 1)); // dummyOnes + internals.push_back(shape(_numSamples, 4*_numOut)); // gates + + return false; + } + + void finalize(const std::vector &input, std::vector &output) + { + CV_Assert(blobs.size() == 3); + CV_Assert(input.size() == 1); + const Mat& inp0 = *input[0]; + + Mat &Wh = blobs[0], &Wx = blobs[1]; + int numOut = Wh.size[1]; + int numInp = Wx.size[1]; + + if (!outTailShape.empty()) + CV_Assert(total(outTailShape) == numOut); + else + outTailShape.assign(1, numOut); + + if (useTimestampDim) + { + CV_Assert(inp0.dims >= 2 && (int)inp0.total(2) == numInp); + numTimeStamps = inp0.size[0]; + numSamples = inp0.size[1]; + } + else + { + CV_Assert(inp0.dims >= 2 && (int)inp0.total(1) == numInp); + numTimeStamps = 1; + numSamples = inp0.size[0]; + } + + outTsShape.clear(); + outTsShape.push_back(numSamples); + outTsShape.insert(outTsShape.end(), outTailShape.begin(), outTailShape.end()); + + allocated = true; + } + + void forward(std::vector &input, std::vector &output, std::vector &internals) + { + const Mat &Wh = blobs[0]; + const Mat &Wx = blobs[1]; + const Mat &bias = blobs[2]; + + int numOut = Wh.size[1]; + + Mat hInternal = internals[0], cInternal = internals[1], + dummyOnes = internals[2], gates = internals[3]; + hInternal.setTo(0.); + cInternal.setTo(0.); + dummyOnes.setTo(1.); + + int numSamplesTotal = numTimeStamps*numSamples; + Mat xTs = input[0]->reshape(1, numSamplesTotal); + + Mat hOutTs = output[0].reshape(1, numSamplesTotal); + Mat cOutTs = produceCellOutput ? output[1].reshape(1, numSamplesTotal) : Mat(); + + for (int ts = 0; ts < numTimeStamps; ts++) + { + Range curRowRange(ts*numSamples, (ts + 1)*numSamples); + Mat xCurr = xTs.rowRange(curRowRange); + + gemm(xCurr, Wx, 1, gates, 0, gates, GEMM_2_T); // Wx * x_t + gemm(hInternal, Wh, 1, gates, 1, gates, GEMM_2_T); //+Wh * h_{t-1} + gemm(dummyOnes, bias, 1, gates, 1, gates); //+b + + Mat getesIFO = gates.colRange(0, 3*numOut); + Mat gateI = gates.colRange(0*numOut, 1*numOut); + Mat gateF = gates.colRange(1*numOut, 2*numOut); + Mat gateO = gates.colRange(2*numOut, 3*numOut); + Mat gateG = gates.colRange(3*numOut, 4*numOut); + + sigmoid(getesIFO, getesIFO); + tanh(gateG, gateG); + + //compute c_t + multiply(gateF, cInternal, gateF); // f_t (*) c_{t-1} + multiply(gateI, gateG, gateI); // i_t (*) g_t + add(gateF, gateI, cInternal); // c_t = f_t (*) c_{t-1} + i_t (*) g_t + + //compute h_t + tanh(cInternal, hInternal); + multiply(gateO, hInternal, hInternal); + + //save results in output blobs + hInternal.copyTo(hOutTs.rowRange(curRowRange)); + if (produceCellOutput) + cInternal.copyTo(cOutTs.rowRange(curRowRange)); + } + } +}; + +Ptr LSTMLayer::create(const LayerParams& params) +{ + return Ptr(new LSTMLayerImpl(params)); +} + +int LSTMLayer::inputNameToIndex(String inputName) +{ + if (inputName.toLowerCase() == "x") + return 0; + return -1; +} + +int LSTMLayer::outputNameToIndex(String outputName) +{ + if (outputName.toLowerCase() == "h") + return 0; + else if (outputName.toLowerCase() == "c") + return 1; + return -1; +} + + +class RNNLayerImpl : public RNNLayer +{ + int numX, numH, numO; + int numSamples, numTimestamps, numSamplesTotal; + int dtype; + Mat Whh, Wxh, bh; + Mat Who, bo; + bool produceH; + +public: + + RNNLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + type = "RNN"; + produceH = false; + } + + void setProduceHiddenOutput(bool produce = false) + { + produceH = produce; + } + + void setWeights(const Mat &W_xh, const Mat &b_h, const Mat &W_hh, const Mat &W_ho, const Mat &b_o) + { + CV_Assert(W_hh.dims == 2 && W_xh.dims == 2); + CV_Assert(W_hh.size[0] == W_xh.size[0] && W_hh.size[0] == W_hh.size[1] && (int)b_h.total() == W_xh.size[0]); + CV_Assert(W_ho.size[0] == (int)b_o.total()); + CV_Assert(W_ho.size[1] == W_hh.size[1]); + + blobs.resize(5); + blobs[0] = Mat(W_xh.clone()); + blobs[1] = Mat(b_h.clone()); + blobs[2] = Mat(W_hh.clone()); + blobs[3] = Mat(W_ho.clone()); + blobs[4] = Mat(b_o.clone()); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() >= 1 && inputs.size() <= 2); + + Mat Who_ = blobs[3]; + Mat Wxh_ = blobs[0]; + + int numTimestamps_ = inputs[0][0]; + int numSamples_ = inputs[0][1]; + + int numO_ = Who_.rows; + int numH_ = Wxh_.rows; + + outputs.clear(); + int dims[] = {numTimestamps_, numSamples_, numO_}; + outputs.push_back(shape(dims, 3)); + dims[2] = numH_; + if (produceH) + outputs.push_back(shape(dims, 3)); + + internals.assign(2, shape(numSamples_, numH_)); + internals.push_back(shape(numSamples_, 1)); + + return false; + } + + void finalize(const std::vector &input, std::vector &output) + { + CV_Assert(input.size() >= 1 && input.size() <= 2); + + Wxh = blobs[0]; + bh = blobs[1]; + Whh = blobs[2]; + Who = blobs[3]; + bo = blobs[4]; + + numH = Wxh.rows; + numX = Wxh.cols; + numO = Who.rows; + + const Mat& inp0 = *input[0]; + + CV_Assert(inp0.dims >= 2); + CV_Assert(inp0.total(2) == numX); + dtype = CV_32F; + CV_Assert(inp0.type() == dtype); + numTimestamps = inp0.size[0]; + numSamples = inp0.size[1]; + numSamplesTotal = numTimestamps * numSamples; + + bh = bh.reshape(1, 1); //is 1 x numH Mat + bo = bo.reshape(1, 1); //is 1 x numO Mat + } + + void reshapeOutput(std::vector &output) + { + output.resize(produceH ? 2 : 1); + int sz0[] = { numTimestamps, numSamples, numO }; + output[0].create(3, sz0, dtype); + if (produceH) + { + int sz1[] = { numTimestamps, numSamples, numH }; + output[1].create(3, sz1, dtype); + } + } + + void forward(std::vector &input, std::vector &output, std::vector &internals) + { + Mat xTs = input[0]->reshape(1, numSamplesTotal); + Mat oTs = output[0].reshape(1, numSamplesTotal); + Mat hTs = produceH ? output[1].reshape(1, numSamplesTotal) : Mat(); + Mat hCurr = internals[0]; + Mat hPrev = internals[1]; + Mat dummyBiasOnes = internals[2]; + + hPrev.setTo(0.); + dummyBiasOnes.setTo(1.); + + for (int ts = 0; ts < numTimestamps; ts++) + { + Range curRowRange = Range(ts * numSamples, (ts + 1) * numSamples); + Mat xCurr = xTs.rowRange(curRowRange); + + gemm(hPrev, Whh, 1, hCurr, 0, hCurr, GEMM_2_T); // W_{hh} * h_{prev} + gemm(xCurr, Wxh, 1, hCurr, 1, hCurr, GEMM_2_T); //+W_{xh} * x_{curr} + gemm(dummyBiasOnes, bh, 1, hCurr, 1, hCurr); //+bh + tanh(hCurr, hPrev); + + Mat oCurr = oTs.rowRange(curRowRange); + gemm(hPrev, Who, 1, oCurr, 0, oCurr, GEMM_2_T); // W_{ho} * h_{prev} + gemm(dummyBiasOnes, bo, 1, oCurr, 1, oCurr); //+b_o + tanh(oCurr, oCurr); + + if (produceH) + hPrev.copyTo(hTs.rowRange(curRowRange)); + } + } +}; + +CV_EXPORTS_W Ptr RNNLayer::create(const LayerParams& params) +{ + return Ptr(new RNNLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/reshape_layer.cpp b/modules/dnn/src/layers/reshape_layer.cpp new file mode 100644 index 0000000000..a5fa088668 --- /dev/null +++ b/modules/dnn/src/layers/reshape_layer.cpp @@ -0,0 +1,247 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +static void computeShapeByReshapeMask(const MatShape &srcShape, + const MatShape &maskShape, + Range srcRange /*= Range::all()*/, + MatShape& dstShape) +{ + int srcShapeSize = (int)srcShape.size(); + int maskShapeSize = (int)maskShape.size(); + + if (srcRange == Range::all()) + srcRange = Range(0, srcShapeSize); + else + { + int sz = srcRange.size(); + srcRange.start = clamp(srcRange.start, srcShapeSize); + srcRange.end = srcRange.end == INT_MAX ? srcShapeSize : srcRange.start + sz; + } + + bool explicitMask = !maskShape.empty(); // All mask values are positive. + for (int i = 0, n = maskShape.size(); i < n && explicitMask; ++i) + { + explicitMask = maskShape[i] > 0; + } + // Working range of source shape is a range where area(src) == area(mask). + if (explicitMask) + { + int maskTotal = total(maskShape); + for (int i = srcRange.start + 1; i < srcRange.end; ++i) + { + if (total(srcShape, i, srcRange.end) != maskTotal) + { + srcRange.start = i - 1; + break; + } + } + CV_Assert(total(srcShape, srcRange.start, srcRange.end) == maskTotal); + } + + CV_Assert(0 <= srcRange.start && srcRange.start <= srcRange.end && srcRange.end <= srcShapeSize); + int dstShapeSize = srcShapeSize - srcRange.size() + maskShapeSize; + dstShape.resize(dstShapeSize); + + std::copy(srcShape.begin(), srcShape.begin() + srcRange.start, dstShape.begin()); + std::copy(srcShape.begin() + srcRange.end, srcShape.begin() + srcShapeSize, dstShape.begin() + srcRange.start + maskShapeSize); + + int inferDim = -1; + for (int i = 0; i < maskShapeSize; i++) + { + if (maskShape[i] > 0) + { + dstShape[srcRange.start + i] = maskShape[i]; + } + else if (maskShape[i] == 0) + { + if (srcRange.start + i >= srcShapeSize) + CV_Error(Error::StsBadArg, format("Copy dim[%d] (which has zero size) is out of the source shape bounds", srcRange.start + i)); + dstShape[srcRange.start + i] = srcShape[srcRange.start + i]; + } + else if (maskShape[i] == -1) + { + if (inferDim != -1) + CV_Error(Error::StsAssert, "Duplicate of inferred dim (which is denoted by -1)"); + inferDim = srcRange.start + i; + dstShape[inferDim] = 1; + } + else + CV_Error(Error::StsBadArg, "maskShape[i] >= -1"); + } + + size_t srcTotal = total(srcShape); + size_t dstTotal = total(dstShape); + + if (inferDim != -1) + { + if (srcTotal % dstTotal != 0) + CV_Error(Error::StsBackTrace, "Can't infer a dim denoted by -1"); + + dstShape[inferDim] = (int)(srcTotal / dstTotal); + } + else + { + CV_Assert(srcTotal == dstTotal); + } +} + + +class ReshapeLayerImpl : public ReshapeLayer +{ +public: + ReshapeLayerImpl(const LayerParams& params): + performReordering(false) + { + setParamsFrom(params); + int axis = params.get("axis", 0); + int numAxes = params.get("num_axes", -1); + enableReordering = params.get("reorder_dims", false); + CV_Assert(numAxes >= -1); + newShapeRange = (numAxes == -1) ? Range(axis, INT_MAX) : Range(axis, axis + numAxes); + + newShapeDesc.clear(); + if (params.has("dim")) + { + const DictValue ¶mShape = params.get("dim"); + int i, dims = paramShape.size(); + newShapeDesc.resize(dims); + for (i = 0; i < dims; i++) + newShapeDesc[i] = paramShape.get(i); + } + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + outputs.clear(); + + for (size_t i = 0; i < inputs.size(); i++) + { + outputs.push_back(MatShape()); + computeShapeByReshapeMask(inputs[i], newShapeDesc, newShapeRange, outputs.back()); + } + internals = outputs; + + return true; + } + + void finalize(const std::vector &inputs, std::vector &outputs) + { + CV_Assert(inputs.size()); + CV_Assert(outputs.size()); + Mat srcBlob = *inputs[0]; + int dims = srcBlob.dims; + MatShape inputShape = shape(srcBlob), outShape = shape(outputs[0]); + + // input.total() == output.total(). So if reordering is require, + // one of the sizes will be are not equal. + // Example where reordering is require: from 1x128x4x4 to 1x2048 + // Example where reordering is NOT require: from 1x1024x1x1 to 1x1024. + bool reorderingRequire = false; + const int minDims = min(dims, (int)outShape.size()); + for (int i = 0; !reorderingRequire && i < minDims; ++i) + reorderingRequire = inputShape[i] != outShape[i]; + performReordering = enableReordering && reorderingRequire; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for (size_t i = 0; i < inputs.size(); i++) + { + Mat srcBlob = *inputs[i]; + MatShape inputShape = shape(srcBlob), outShape = shape(outputs[i]); + + if (performReordering) + { + float *dstData = internals[i].ptr(); + const float *srcData = srcBlob.ptr(); + + int num = inputShape[0], channels = inputShape[1], height = inputShape[2], width = inputShape[3]; + int total = num*channels*height*width; + for(int i_n = 0; i_n < num; i_n++) { + for(int i_c = 0; i_c < channels; i_c++) { + for(int i_h = 0; i_h < height; i_h++) { + for(int i_w = 0; i_w < width; i_w++) { + int src_i = channels*height*width*i_n + height*width*i_c + width*i_h + i_w; + int dst_i = channels*height*width*i_n + i_c + channels*width*i_h + channels*i_w; + + CV_Assert(dst_i < total); + CV_Assert(src_i < total); + + dstData[dst_i] = srcData[src_i]; + } + } + } + } + internals[i].copyTo(outputs[i]); + } + else + { + if (outputs[i].data != srcBlob.data) + srcBlob.reshape(1, outShape).copyTo(outputs[i]); + } + } + } + +private: + std::vector > outShapes; + bool enableReordering, performReordering; +}; + +Ptr ReshapeLayer::create(const LayerParams& params) +{ + return Ptr(new ReshapeLayerImpl(params)); +} + + +} +} diff --git a/modules/dnn/src/layers/scale_layer.cpp b/modules/dnn/src/layers/scale_layer.cpp new file mode 100644 index 0000000000..738b7d031c --- /dev/null +++ b/modules/dnn/src/layers/scale_layer.cpp @@ -0,0 +1,147 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Implementation of Scale layer. +*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class ScaleLayerImpl : public ScaleLayer +{ +public: + ScaleLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + hasBias = params.get("bias_term", false); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals); + return true; + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide(); + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + CV_Assert(blobs.size() == 1 + hasBias); + + for (size_t ii = 0; ii < outputs.size(); ii++) + { + Mat &inpBlob = *inputs[ii]; + Mat &outBlob = outputs[ii]; + + CV_Assert(inpBlob.size[1] == blobs[0].total()); + if (hasBias) + CV_Assert(inpBlob.size[1] == blobs[1].total()); + + CV_Assert(inpBlob.type() == CV_32F && outBlob.type() == CV_32F); + + for( int cn = 0; cn < inpBlob.size[0]; cn++ ) + { + for (int n = 0; n < inpBlob.size[1]; n++) + { + float w = blobs[0].at(n); + float b = hasBias ? blobs[1].at(n) : 0; + Mat outBlobPlane = getPlane(outBlob, cn, n); + Mat inpBlobPlane = getPlane(inpBlob, cn, n); + inpBlobPlane.convertTo(outBlobPlane, CV_32F, w, b); + } + } + } + } + + virtual Ptr tryAttach(const Ptr& node) + { + switch (node->backendId) + { + case DNN_BACKEND_HALIDE: + { +#ifdef HAVE_HALIDE + auto base = node.dynamicCast(); + Halide::Func& input = base->funcs.back(); + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = attachHalide(input(x, y, c, n)); + return Ptr(new HalideBackendNode(base, top)); +#endif // HAVE_HALIDE + break; + } + } + return Ptr(); + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer input = halideBuffer(inputs[0]); + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = attachHalide(input(x, y, c, n)); + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + +#ifdef HAVE_HALIDE + // attachHalide can work both with Halide::Buffer and Halide::Func. In the + // second case it will be a fusion. + Halide::Func attachHalide(const Halide::Expr& input) + { + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + Halide::Var x("x"), y("y"), c("c"), n("n"); + + const int numChannels = blobs[0].total(); + + auto weights = wrapToHalideBuffer(blobs[0], {numChannels}); + Halide::Expr topExpr = input * weights(c); + if (hasBias) + { + auto bias = wrapToHalideBuffer(blobs[1], {numChannels}); + topExpr += bias(c); + } + top(x, y, c, n) = topExpr; + return top; + } +#endif // HAVE_HALIDE + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + long flops = 0; + for(int i = 0; i < inputs.size(); i++) + { + flops += 2*total(inputs[i]); + } + return flops; + } +}; + + +Ptr ScaleLayer::create(const LayerParams& params) +{ + return Ptr(new ScaleLayerImpl(params)); +} + +} // namespace dnn +} // namespace cv diff --git a/modules/dnn/src/layers/shift_layer.cpp b/modules/dnn/src/layers/shift_layer.cpp new file mode 100644 index 0000000000..a26157f2bb --- /dev/null +++ b/modules/dnn/src/layers/shift_layer.cpp @@ -0,0 +1,96 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Implementation of shift layer, which adds up const values to blob. +*/ + +#include "../precomp.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class ShiftLayerImpl : public ShiftLayer +{ +public: + ShiftLayerImpl(const LayerParams ¶ms) + { + setParamsFrom(params); + CV_Assert(blobs.size() == 1); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals); + internals.assign(1, shape(1, total(inputs[0], 2))); + return true; + } + + virtual void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + CV_Assert(inputs.size() > 0); + CV_Assert(blobs.size() > 0); + + if(inputs[0]->dims == blobs[0].dims) + { + for (size_t ii = 0; ii < outputs.size(); ii++) + { + Mat &inpBlob = *inputs[ii]; + Mat &outBlob = outputs[ii]; + + outBlob = inpBlob + blobs[0]; + } + } + else + { + Mat biasOnesMat = internals[0]; + biasOnesMat.setTo(1); + for (size_t ii = 0; ii < outputs.size(); ii++) + { + Mat &inpBlob = *inputs[ii]; + Mat &outBlob = outputs[ii]; + + inpBlob.copyTo(outBlob); + + for (int n = 0; n < inpBlob.size[0]; n++) + { + Mat dstMat(inpBlob.size[1], inpBlob.size[2] * inpBlob.size[3], + outBlob.type(), outBlob.ptr(n)); + gemm(blobs[0], biasOnesMat, 1, dstMat, 1, dstMat); //TODO: gemv + } + } + } + } + + virtual int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + long flops = 0; + + for(int i= 0; i < inputs.size(); i++) + { + flops += total(inputs[i]); + } + + return flops; + } +}; + +Ptr ShiftLayer::create(const LayerParams& params) +{ + return Ptr(new ShiftLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/slice_layer.cpp b/modules/dnn/src/layers/slice_layer.cpp new file mode 100644 index 0000000000..4449f93e4c --- /dev/null +++ b/modules/dnn/src/layers/slice_layer.cpp @@ -0,0 +1,140 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include + +namespace cv +{ +namespace dnn +{ + +class SliceLayerImpl : public SliceLayer +{ +public: + SliceLayerImpl(const LayerParams& params) + { + setParamsFrom(params); + axis = params.get("axis", 1); + + if (params.has("slice_point")) + { + const DictValue &indicesValue = params.get("slice_point"); + int i, n = indicesValue.size(); + sliceIndices.resize(n); + for (i = 0; i < n; i++) + sliceIndices[i] = indicesValue.get(i); + } + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() == 1); + + outputs.clear(); + + MatShape inpShape = inputs[0]; + int cAxis = clamp(axis, inpShape.size()); + int axisSize = inpShape[cAxis]; + + if (sliceIndices.size()) //divide blob with respect to passed parameters + { + std::vector outAxisSize; + int prevSlice = 0; + + for (size_t i = 0; i < sliceIndices.size(); i++) + { + if (!(prevSlice < sliceIndices[i] && sliceIndices[i] < axisSize)) + CV_Error(Error::StsBadArg, "Slice indices should be positive, increased and don't exceed size of sliced dimension"); + + outAxisSize.push_back(sliceIndices[i] - prevSlice); + prevSlice = sliceIndices[i]; + } + outAxisSize.push_back(axisSize - prevSlice); + + for (size_t i = 0; i < outAxisSize.size(); i++) + { + inpShape[cAxis] = outAxisSize[i]; + outputs.push_back(inpShape); + } + } + else //divide blob with respect to count of output blobs + { + CV_Assert(requiredOutputs > 0 && axisSize % requiredOutputs == 0); + int outAxisSize = axisSize / (int)requiredOutputs; + + for (size_t i = 0; i < requiredOutputs; i++) + { + inpShape[cAxis] = outAxisSize; + outputs.push_back(inpShape); + } + } + + return false; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + const Mat& inpMat = *inputs[0]; + std::vector ranges(inpMat.dims, Range::all()); + int cAxis = clamp(axis, inpMat.dims); + + ranges[cAxis].start = 0; + for (size_t i = 0; i < outputs.size(); i++) + { + ranges[cAxis].end = ranges[cAxis].start + outputs[i].size[cAxis]; + inpMat(&ranges[0]).copyTo(outputs[i]); + ranges[cAxis].start = ranges[cAxis].end; + } + } +}; + +Ptr SliceLayer::create(const LayerParams& params) +{ + return Ptr(new SliceLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/softmax_layer.cpp b/modules/dnn/src/layers/softmax_layer.cpp new file mode 100644 index 0000000000..fc80fc1cd5 --- /dev/null +++ b/modules/dnn/src/layers/softmax_layer.cpp @@ -0,0 +1,213 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" +#include "op_halide.hpp" +#include +#include +using std::max; + +namespace cv +{ +namespace dnn +{ + +class SoftMaxLayerImpl : public SoftmaxLayer +{ +public: + + SoftMaxLayerImpl(const LayerParams& params) + { + axisRaw = params.get("axis", 1); + logSoftMax = params.get("log_softmax", false); + setParamsFrom(params); + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + bool inplace = Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals); + MatShape shape = inputs[0]; + int cAxis = clamp(axisRaw, shape.size()); + shape[cAxis] = 1; + internals.assign(1, shape); + return inplace; + } + + virtual bool supportBackend(int backendId) + { + return backendId == DNN_BACKEND_DEFAULT || + backendId == DNN_BACKEND_HALIDE && haveHalide() && axisRaw == 1; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + const Mat &src = *inputs[0]; + Mat &dst = outputs[0]; + + int axis = clamp(axisRaw, src.dims); + size_t outerSize = src.total(0, axis), channels = src.size[axis], + innerSize = src.total(axis + 1); + + CV_Assert(src.type() == CV_32F); + CV_Assert(src.isContinuous() && dst.isContinuous()); + + const float *srcPtr = src.ptr(); + float *dstPtr = dst.ptr(); + float *bufPtr = internals[0].ptr(); + + size_t outerStep = src.total(axis); + size_t cnStep = src.total(axis + 1); + + //compute max along axis + for (size_t outerDim = 0; outerDim < outerSize; outerDim++) + { + size_t srcOffset = outerDim * outerStep; + size_t bufOffset = outerDim * cnStep; + + memcpy(bufPtr + bufOffset, srcPtr + srcOffset, innerSize * sizeof(float)); + + for (size_t cnDim = 1; cnDim < channels; cnDim++) + { + for (size_t i = 0; i < innerSize; i++) + bufPtr[bufOffset + i] = std::max(bufPtr[bufOffset + i], srcPtr[srcOffset + cnDim * cnStep + i]); + } + } + + //subtract max + for (size_t outerDim = 0; outerDim < outerSize; outerDim++) + { + size_t srcOffset = outerDim * outerStep; + size_t bufOffset = outerDim * cnStep; + + for (size_t cnDim = 0; cnDim < channels; cnDim++) + { + for (size_t i = 0; i < innerSize; i++) + dstPtr[srcOffset + cnDim * cnStep + i] = srcPtr[srcOffset + cnDim * cnStep + i] - bufPtr[bufOffset + i]; + } + } + + cv::exp(dst, dst); + + for (size_t outerDim = 0; outerDim < outerSize; outerDim++) + { + size_t srcOffset = outerDim * outerStep; + size_t bufOffset = outerDim * cnStep; + + //sum exp along axis + for (size_t i = 0; i < innerSize; i++) + bufPtr[bufOffset + i] = 0.f; + + for (size_t cnDim = 0; cnDim < channels; cnDim++) + { + for (size_t i = 0; i < innerSize; i++) + bufPtr[bufOffset + i] += dstPtr[srcOffset + cnDim * cnStep + i]; + } + + //divide by computed sum + for (size_t cnDim = 0; cnDim < channels; cnDim++) + { + for (size_t i = 0; i < innerSize; i++) + dstPtr[srcOffset + cnDim * cnStep + i] /= bufPtr[bufOffset + i]; + } + if (logSoftMax) + { + for (size_t cnDim = 0; cnDim < channels; cnDim++) + { + for (size_t i = 0; i < innerSize; i++) + dstPtr[srcOffset + cnDim * cnStep + i] = log(dstPtr[srcOffset + cnDim * cnStep + i]); + } + } + } + } + + virtual Ptr initHalide(const std::vector > &inputs) + { +#ifdef HAVE_HALIDE + Halide::Buffer inputBuffer = halideBuffer(inputs[0]); + int inW, inH, inC, inN; + getCanonicalSize(inputBuffer, &inW, &inH, &inC, &inN); + + if (inW != 1 || inH != 1) + CV_Error(cv::Error::StsNotImplemented, + "Halide backend for SoftMax with spatial size " + "more than 1x1 is not implemented"); + + Halide::Var x("x"), y("y"), c("c"), n("n"); + Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name)); + + Halide::Func expInput("expInput"); + Halide::RDom r(0, inW, 0, inH, 0, inC); + expInput(x, y, c, n) = exp(inputBuffer(x, y, c, n)); + Halide::Expr globalSum = sum(expInput(r.x, r.y, r.z, n)); + top(x, y, c, n) = expInput(x, y, c, n) / globalSum; + return Ptr(new HalideBackendNode(top)); +#endif // HAVE_HALIDE + return Ptr(); + } + + int64 getFLOPS(const std::vector &inputs, + const std::vector &outputs) const + { + (void)outputs; // suppress unused variable warning + int64 flops = 0; + + for (int i = 0; i < inputs.size(); i++) + { + flops += 4*total(inputs[i]); + } + + return flops; + } + + int axisRaw; +}; + +Ptr SoftmaxLayer::create(const LayerParams& params) +{ + return Ptr(new SoftMaxLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/layers/split_layer.cpp b/modules/dnn/src/layers/split_layer.cpp new file mode 100644 index 0000000000..6242172d08 --- /dev/null +++ b/modules/dnn/src/layers/split_layer.cpp @@ -0,0 +1,97 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include "layers_common.hpp" + +namespace cv +{ +namespace dnn +{ + +class SplitLayerImpl : public SplitLayer +{ +public: + SplitLayerImpl(const LayerParams ¶ms) + { + setParamsFrom(params); + //TODO: maybe "top_count" param is useless because it can be determined by output connections number + if (params.has("top_count")) + { + outputsCount = params.get("top_count"); + CV_Assert(outputsCount >= 0); + } + else + { + outputsCount = -1; + } + } + + bool getMemoryShapes(const std::vector &inputs, + const int requiredOutputs, + std::vector &outputs, + std::vector &internals) const + { + CV_Assert(inputs.size() == 1); + + Layer::getMemoryShapes(inputs, max(1, outputsCount >= 0 ? outputsCount : requiredOutputs), + outputs, internals); + return true; + } + + void forward(std::vector &inputs, std::vector &outputs, std::vector &internals) + { + for (size_t i = 0; i < outputs.size(); i++) + { + CV_Assert(inputs[0]->total() == outputs[i].total()); + if (outputs[i].data != inputs[0]->data) + inputs[0]->copyTo(outputs[i]); + } + } +}; + +Ptr SplitLayer::create(const LayerParams& params) +{ + return Ptr(new SplitLayerImpl(params)); +} + +} +} diff --git a/modules/dnn/src/op_halide.cpp b/modules/dnn/src/op_halide.cpp new file mode 100644 index 0000000000..9678359137 --- /dev/null +++ b/modules/dnn/src/op_halide.cpp @@ -0,0 +1,206 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "op_halide.hpp" + +#ifdef HAVE_HALIDE +#include +#endif // HAVE_HALIDE + +namespace cv +{ +namespace dnn +{ + +#ifdef HAVE_HALIDE +Halide::Buffer wrapToHalideBuffer(const Mat& mat) +{ + int n, c, w, h; + getCanonicalSize(mat.size, &w, &h, &c, &n); + return wrapToHalideBuffer(mat, {w, h, c, n}); +} + +Halide::Buffer wrapToHalideBuffer(const Mat& mat, + const std::vector& sizes) +{ + Halide::Buffer buffer((float*)mat.data, sizes); + buffer.set_host_dirty(); // Indicate that data is on CPU. + return buffer; +} + +Halide::Buffer<> halideBuffer(const Ptr& ptr) +{ + CV_Assert(!ptr.empty()); + return ptr.dynamicCast()->buffer; +} + +std::vector > halideBuffers(const std::vector >& ptrs) +{ + std::vector > vec; + vec.reserve(ptrs.size()); + for (const Ptr& ptr : ptrs) + { + vec.push_back(halideBuffer(ptr)); + } + return vec; +} + +void getCanonicalSize(const Halide::Buffer<>& buffer, int* width, int* height, + int* channels, int* batch) +{ + CV_Assert(buffer.dimensions() == 4); + *width = buffer.extent(0); + *height = buffer.extent(1); + *channels = buffer.extent(2); + *batch = buffer.extent(3); +} + +HalideBackendNode::HalideBackendNode(const Halide::Func& func) + : BackendNode(DNN_BACKEND_HALIDE), funcs(1, func) {} + +HalideBackendNode::HalideBackendNode(const std::vector& funcs) + : BackendNode(DNN_BACKEND_HALIDE), funcs(funcs) {} + +HalideBackendNode::HalideBackendNode(const Ptr& base, + const Halide::Func& top) + : BackendNode(DNN_BACKEND_HALIDE), funcs(base->funcs) +{ + funcs.back() = top; +} + +HalideBackendWrapper::HalideBackendWrapper(int targetId, const cv::Mat& m) + : BackendWrapper(DNN_BACKEND_HALIDE, targetId) +{ + buffer = wrapToHalideBuffer(m); + if (targetId == DNN_TARGET_CPU) + { + return; + } + else if (targetId == DNN_TARGET_OPENCL) + { + buffer.copy_to_device(halide_opencl_device_interface()); + } + else + CV_Error(Error::StsNotImplemented, "Unknown target identifier"); +} + +HalideBackendWrapper::HalideBackendWrapper(const Ptr& base, + const MatShape& shape) + : BackendWrapper(DNN_BACKEND_HALIDE, base->targetId) +{ + int w, h, c, n; + getCanonicalSize(shape, &w, &h, &c, &n); + Halide::Buffer baseBuffer = halideBuffer(base); + buffer = Halide::Buffer((float*)baseBuffer.raw_buffer()->host, + {w, h, c, n}); + if (baseBuffer.has_device_allocation()) + { + buffer.raw_buffer()->device = baseBuffer.raw_buffer()->device; + buffer.raw_buffer()->device_interface = baseBuffer.raw_buffer()->device_interface; + buffer.set_device_dirty(); + } + else + { + buffer.set_host_dirty(); // Indicate that data is on CPU. + CV_Assert(targetId == DNN_TARGET_CPU); + } +} + +void HalideBackendWrapper::copyToHost() +{ + CV_Assert(targetId == DNN_TARGET_CPU || buffer.device_dirty()); + if (buffer.device_dirty()) + { + buffer.device_sync(); + buffer.copy_to_host(); + } +} +#endif // HAVE_HALIDE + +void getCanonicalSize(const MatSize& size, int* width, int* height, + int* channels, int* batch) +{ + const int dims = size.p[-1]; + CV_Assert(dims == 2 || dims == 4); + *batch = size[0]; + *channels = size[1]; + if (dims == 4) + { + *width = size[3]; + *height = size[2]; + } + else + { + *width = 1; + *height = 1; + } +} + +void getCanonicalSize(const MatShape& shape, int* width, int* height, + int* channels, int* batch) +{ + const int dims = shape.size(); + CV_Assert(dims == 2 || dims == 4); + *batch = shape[0]; + *channels = shape[1]; + if (dims == 4) + { + *width = shape[3]; + *height = shape[2]; + } + else + { + *width = 1; + *height = 1; + } +} + +void compileHalide(std::vector &outputs, Ptr& node, int targetId) +{ +#ifdef HAVE_HALIDE + CV_Assert(!node.empty()); + Halide::Func& top = node.dynamicCast()->funcs.back(); + + int outW, outH, outC, outN; + Halide::Var x("x"), y("y"), c("c"), n("n"); + getCanonicalSize(outputs[0].size, &outW, &outH, &outC, &outN); + top.bound(x, 0, outW).bound(y, 0, outH) + .bound(c, 0, outC).bound(n, 0, outN); + + Halide::Target target = Halide::get_host_target(); + target.set_feature(Halide::Target::NoAsserts); + if (targetId == DNN_TARGET_OPENCL) + { + target.set_feature(Halide::Target::OpenCL); + } + CV_Assert(target.supported()); + top.compile_jit(target); +#endif // HAVE_HALIDE +} + +void forwardHalide(std::vector > &outputs, + const Ptr& node) +{ +#ifdef HAVE_HALIDE + CV_Assert(!node.empty()); + Halide::Func& top = node.dynamicCast()->funcs.back(); + auto outputBuffers = halideBuffers(outputs); + top.realize(Halide::Realization(outputBuffers)); +#endif // HAVE_HALIDE +} + +bool haveHalide() +{ +#ifdef HAVE_HALIDE + return true; +#else + return false; +#endif // HAVE_HALIDE +} + +} // namespace dnn +} // namespace cv diff --git a/modules/dnn/src/op_halide.hpp b/modules/dnn/src/op_halide.hpp new file mode 100644 index 0000000000..f91e3fb65a --- /dev/null +++ b/modules/dnn/src/op_halide.hpp @@ -0,0 +1,84 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef __OPENCV_DNN_OP_HALIDE_HPP__ +#define __OPENCV_DNN_OP_HALIDE_HPP__ + +#include "precomp.hpp" + +#ifdef HAVE_HALIDE +#include +#endif // HAVE_HALIDE + +namespace cv +{ +namespace dnn +{ +#ifdef HAVE_HALIDE + // Returns four-dimensional buffer with float32 type that wrap cv::Mat data. + // No data copy here. + Halide::Buffer wrapToHalideBuffer(const Mat& mat); + + Halide::Buffer wrapToHalideBuffer(const Mat& mat, + const std::vector& shape); + + // Extract batch size, number of channels, width and height from buffer. + void getCanonicalSize(const Halide::Buffer<>& buffer, int* width, int* height, + int* channels, int* batch); + + // Cast pointer and create copy of Halide buffer. No data copy. + Halide::Buffer<> halideBuffer(const Ptr& ptr); + + std::vector > halideBuffers(const std::vector >& ptrs); + + class HalideBackendNode : public BackendNode + { + public: + HalideBackendNode(const Halide::Func& func); + + HalideBackendNode(const std::vector& funcs); + + // Initialize from the node but replace last function to . + // It's using in case of layers fusing when we want to keep functions of + // root layer but replace top by fused one (i.e. conv+padding to relu+padding). + HalideBackendNode(const Ptr& base, const Halide::Func& top); + + std::vector funcs; + }; + + class HalideBackendWrapper : public BackendWrapper + { + public: + HalideBackendWrapper(int targetId, const cv::Mat& m); + + HalideBackendWrapper(const Ptr& base, const MatShape& shape); + + virtual void copyToHost(); + + Halide::Buffer buffer; + }; +#endif // HAVE_HALIDE + + // Extract batch size, number of channels, width and height from MatSize. + void getCanonicalSize(const MatSize& size, int* width, int* height, + int* channels, int* batch); + + void getCanonicalSize(const MatShape& shape, int* width, int* height, + int* channels, int* batch); + + // Realize Halide pipeline into output blobs. + void forwardHalide(std::vector > &outputs, + const Ptr& node); + + // Compile Halide pipeline to specific target. Use outputs to set bounds of functions. + void compileHalide(std::vector &outputs, Ptr& node, int targetId); + + bool haveHalide(); +} // namespace dnn +} // namespace cv + +#endif // __OPENCV_DNN_OP_HALIDE_HPP__ diff --git a/modules/dnn/src/opencl/activations.cl b/modules/dnn/src/opencl/activations.cl new file mode 100644 index 0000000000..58da4db4d0 --- /dev/null +++ b/modules/dnn/src/opencl/activations.cl @@ -0,0 +1,44 @@ +__kernel void ReLUForward(const int count, __global const T* in, __global T* out +#ifndef RELU_NO_SLOPE +, T negative_slope +#endif +) { + int index = get_global_id(0); + if(index < count) +#ifndef RELU_NO_SLOPE + out[index] = in[index] > 0 ? in[index] : in[index] * negative_slope; +#else + out[index] = in[index] > 0 ? in[index] : 0; +#endif +} + +__kernel void TanHForward(const int count, __global T* in, __global T* out) { + int index = get_global_id(0); + if(index < count) + out[index] = tanh(in[index]); +} + +__kernel void SigmoidForward(const int count, __global const T* in, __global T* out) { + int index = get_global_id(0); + if(index < count) + out[index] = 1. / (1. + exp(-in[index])); +} + +__kernel void BNLLForward(const int n, __global const T* in, __global T* out) { + int index = get_global_id(0); + if (index < n) { + out[index] = in[index] > 0 ? in[index] + log(1. + exp(-in[index])) : log(1. + exp(in[index])); + } +} + +__kernel void AbsValForward(const int n, __global const T* in, __global T* out) { + int index = get_global_id(0); + if (index < n) + out[index] = fabs(in[index]); +} + +__kernel void PowForward(const int n, __global const T* in, __global T* out, const T power, const T scale, const T shift) { + int index = get_global_id(0); + if (index < n) + out[index] = pow(shift + scale * in[index], power); +} \ No newline at end of file diff --git a/modules/dnn/src/opencl/col2im.cl b/modules/dnn/src/opencl/col2im.cl new file mode 100644 index 0000000000..30d4664df8 --- /dev/null +++ b/modules/dnn/src/opencl/col2im.cl @@ -0,0 +1,62 @@ +/************************************************************************************* + * Copyright (c) 2015, Advanced Micro Devices, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + **************************************************************************************/ + +__kernel void col2im(const int n, __global const T* data_col, const int col_offset, + const int height, const int width, const int channels, + const int patch_h, const int patch_w, + const int pad_h, const int pad_w, + const int stride_h, const int stride_w, + const int height_col, const int width_col, + __global T* data_im, const int img_offset) +{ + data_col = data_col + col_offset; + data_im = data_im + img_offset; + int index = get_global_id(0); + if(index < n) { + T val = 0; + int w = index % width + pad_w; + int h = (index / width) % height + pad_h; + int c = index / (width * height); + + // compute the start and end of the output + int w_col_start = (w < patch_w) ? 0 : (w - patch_w) / stride_w + 1; + int w_col_end = min(w / stride_w + 1, width_col); + int h_col_start = (h < patch_h) ? 0 : (h - patch_h) / stride_h + 1; + int h_col_end = min(h / stride_h + 1, height_col); + + // equivalent implementation + int offset = + (c * patch_h * patch_w + h * patch_w + w) * height_col * width_col; + int coeff_h_col = (1 - stride_h * patch_w * height_col) * width_col; + int coeff_w_col = (1 - stride_w * height_col * width_col); + for (int h_col = h_col_start; h_col < h_col_end; ++h_col) { + for (int w_col = w_col_start; w_col < w_col_end; ++w_col) { + val += data_col[offset + h_col * coeff_h_col + w_col * coeff_w_col]; + } + } + data_im[index] = val; + } +} diff --git a/modules/dnn/src/opencl/im2col.cl b/modules/dnn/src/opencl/im2col.cl new file mode 100644 index 0000000000..f3f18b5136 --- /dev/null +++ b/modules/dnn/src/opencl/im2col.cl @@ -0,0 +1,71 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +__kernel void im2col(__global const T *im_src, int im_src_offset, + int channels, int height_inp, int width_inp, + int kernel_h, int kernel_w, int pad_h, int pad_w, int stride_h, int stride_w, + int height_out, int width_out, + __global T *im_col, int im_col_offset + ) +{ + int index = get_global_id(0); + if (index >= height_out * width_out * channels) + return; + int j_out = index % width_out; + int i_out = (index / width_out) % height_out; + int c_inp = (index / width_out) / height_out; + + int c_out = c_inp * kernel_h * kernel_w; + int i_inp = i_out * stride_h - pad_h; + int j_inp = j_out * stride_w - pad_w; + + im_src += (c_inp * height_inp + i_inp) * width_inp + j_inp + im_src_offset; + im_col += (c_out * height_out + i_out) * width_out + j_out + im_col_offset; + + for (int ki = 0; ki < kernel_h; ++ki) + for (int kj = 0; kj < kernel_w; ++kj) { + int i = i_inp + ki; + int j = j_inp + kj; + *im_col = (i >= 0 && j >= 0 && i < height_inp && j < width_inp) ? + im_src[ki * width_inp + kj] : 0; + im_col += height_out * width_out; + } +} diff --git a/modules/dnn/src/opencl/lrn.cl b/modules/dnn/src/opencl/lrn.cl new file mode 100644 index 0000000000..2ff03f0edf --- /dev/null +++ b/modules/dnn/src/opencl/lrn.cl @@ -0,0 +1,76 @@ +/************************************************************************************* + * Copyright (c) 2015, Advanced Micro Devices, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + **************************************************************************************/ + +__kernel void LRNComputeOutput(const int nthreads, __global T* in, __global T* scale, const T negative_beta, __global T* out) { + int index = get_global_id(0); + int tmp = get_global_size(0); + for(index; index < nthreads; index += tmp) + out[index] = in[index] * pow(scale[index], negative_beta); +} + +__kernel void LRNFillScale(const int nthreads, __global T* in, const int num, const int channels, const int height, const int width, const int size, const T alpha_over_size, const T k, __global T* scale) { + int index = get_global_id(0); + int tmp = get_global_size(0); + for(index; index < nthreads; index += tmp) { + // find out the local offset + const int w = index % width; + const int h = (index / width) % height; + const int n = index / width / height; + const int offset = (n * channels * height + h) * width + w; + const int step = height * width; + in = in + offset; + scale = scale + offset; + int head = 0; + const int pre_pad = (size - 1) / 2; + const int post_pad = size - pre_pad - 1; + T accum_scale = 0; + // fill the scale at [n, :, h, w] + // accumulate values + while (head < post_pad && head < channels) { + accum_scale += in[head * step] * in[head * step]; + ++head; + } + // both add and subtract + while (head < channels) { + accum_scale += in[head * step] * in[head * step]; + if (head - size >= 0) { + accum_scale -= in[(head - size) * step] + * in[(head - size) * step]; + } + scale[(head - post_pad) * step] = k + accum_scale * alpha_over_size; + ++head; + } + // subtract only + while (head < channels + post_pad) { + if (head - size >= 0) { + accum_scale -= in[(head - size) * step] + * in[(head - size) * step]; + } + scale[(head - post_pad) * step] = k + accum_scale * alpha_over_size; + ++head; + } + } +} \ No newline at end of file diff --git a/modules/dnn/src/opencl/pooling.cl b/modules/dnn/src/opencl/pooling.cl new file mode 100644 index 0000000000..adfd59e6d9 --- /dev/null +++ b/modules/dnn/src/opencl/pooling.cl @@ -0,0 +1,106 @@ +/************************************************************************************* + * Copyright (c) 2015, Advanced Micro Devices, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + **************************************************************************************/ + +__kernel void MaxPoolForward(const int nthreads, + __global T* bottom_data, const int num, const int channels, const int height, const int width, + const int pooled_height, const int pooled_width, const int kernel_h, const int kernel_w, + const int stride_h, const int stride_w, const int pad_h, const int pad_w, + __global T* top_data +#ifdef MASK + , __global float* mask +#endif + ) +{ + int index = get_global_id(0); + int tmp = get_global_size(0); + for(index; index < nthreads; index += tmp) { + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + int hstart = ph * stride_h - pad_h; + int wstart = pw * stride_w - pad_w; + const int hend = min(hstart + kernel_h, height); + const int wend = min(wstart + kernel_w, width); + hstart = max(hstart, 0); + wstart = max(wstart, 0); + T maxval = -FLT_MAX; + int maxidx = -1; + bottom_data = + bottom_data + (n * channels + c) * height * width; + for (int h = hstart; h < hend; ++h) { + for (int w = wstart; w < wend; ++w) { + if (bottom_data[h * width + w] > maxval) { + maxidx = h * width + w; + maxval = bottom_data[maxidx]; + } + } + } + + top_data[index] = maxval; + +#ifdef MASK + mask[index] = maxidx; +#endif + } +} + +__kernel void AvePoolForward(const int nthreads, + __global T* bottom_data, const int num, const int channels, const int height, const int width, + const int pooled_height, const int pooled_width, const int kernel_h, const int kernel_w, + const int stride_h, const int stride_w, const int pad_h, const int pad_w, + __global T* top_data +#ifdef MASK + , __global float* mask // NOT USED +#endif + ) +{ + int index = get_global_id(0); + int tmp = get_global_size(0); + for(index; index < nthreads; index+=tmp) { + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; int hstart = ph * stride_h - pad_h; int wstart = pw * stride_w - pad_w; + int hend = min(hstart + kernel_h, height + pad_h); + int wend = min(wstart + kernel_w, width + pad_w); + const int pool_size = (hend - hstart) * (wend - wstart); + hstart = max(hstart, 0); + wstart = max(wstart, 0); + hend = min(hend, height); + wend = min(wend, width); + T aveval = 0; + bottom_data = + bottom_data + (n * channels + c) * height * width; + for (int h = hstart; h < hend; ++h) { + for (int w = wstart; w < wend; ++w) { + aveval += bottom_data[h * width + w]; + } + } + top_data[index] = aveval / pool_size; + } + +} diff --git a/modules/dnn/src/opencl/softmax.cl b/modules/dnn/src/opencl/softmax.cl new file mode 100644 index 0000000000..e9fcadce39 --- /dev/null +++ b/modules/dnn/src/opencl/softmax.cl @@ -0,0 +1,75 @@ +/************************************************************************************* + * Copyright (c) 2015, Advanced Micro Devices, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + **************************************************************************************/ + +__kernel void kernel_channel_max(const int num, const int channels, + const int spatial_dim, __global const T* data, __global T* out) { + int index = get_global_id(0); + if(index < num * spatial_dim) { + int n = index / spatial_dim; + int s = index % spatial_dim; + T maxval = -FLT_MAX; + for (int c = 0; c < channels; ++c) { + maxval = max(data[(n * channels + c) * spatial_dim + s], maxval); + } + out[index] = maxval; + } +} + +__kernel void kernel_channel_subtract(const int count, + const int num, const int channels, + const int spatial_dim, __global const T* channel_max, __global T* data) { + int index = get_global_id(0); + if(index < count) { + int n = index / channels / spatial_dim; + int s = index % spatial_dim; + data[index] -= channel_max[n * spatial_dim + s]; + } +} + +__kernel void kernel_channel_sum(const int num, const int channels, + const int spatial_dim, __global const T* data, __global T* channel_sum) { + int index = get_global_id(0); + if(index < num * spatial_dim) { + int n = index / spatial_dim; + int s = index % spatial_dim; + T sum = 0; + for (int c = 0; c < channels; ++c) { + sum += data[(n * channels + c) * spatial_dim + s]; + } + channel_sum[index] = sum; + } +} + +__kernel void kernel_channel_div(const int count, + const int num, const int channels, + const int spatial_dim, __global const T* channel_sum, __global T* data) { + int index = get_global_id(0); + if(index < count) { + int n = index / channels / spatial_dim; + int s = index % spatial_dim; + data[index] /= channel_sum[n * spatial_dim + s]; + } +} \ No newline at end of file diff --git a/modules/dnn/src/precomp.hpp b/modules/dnn/src/precomp.hpp new file mode 100644 index 0000000000..b622e38da2 --- /dev/null +++ b/modules/dnn/src/precomp.hpp @@ -0,0 +1,45 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include +#include "cvconfig.h" +#include +#include diff --git a/modules/dnn/src/tensorflow/attr_value.proto b/modules/dnn/src/tensorflow/attr_value.proto new file mode 100644 index 0000000000..26e42bc1a1 --- /dev/null +++ b/modules/dnn/src/tensorflow/attr_value.proto @@ -0,0 +1,60 @@ +syntax = "proto3"; + +package tensorflow; +option cc_enable_arenas = true; +option java_outer_classname = "AttrValueProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +import "tensor.proto"; +import "tensor_shape.proto"; +import "types.proto"; + +// Protocol buffer representing the value for an attr used to configure an Op. +// Comment indicates the corresponding attr type. Only the field matching the +// attr type may be filled. +message AttrValue { + message ListValue { + repeated bytes s = 2; // "list(string)" + repeated int64 i = 3 [packed = true]; // "list(int)" + repeated float f = 4 [packed = true]; // "list(float)" + repeated bool b = 5 [packed = true]; // "list(bool)" + repeated DataType type = 6 [packed = true]; // "list(type)" + repeated TensorShapeProto shape = 7; // "list(shape)" + repeated TensorProto tensor = 8; // "list(tensor)" + // TODO(zhifengc/josh11b): implements list(func) if needed. + } + + oneof value { + bytes s = 2; // "string" + int64 i = 3; // "int" + float f = 4; // "float" + bool b = 5; // "bool" + DataType type = 6; // "type" + TensorShapeProto shape = 7; // "shape" + TensorProto tensor = 8; // "tensor" + ListValue list = 1; // any "list(...)" + + // "func" represents a function. func.name is a function's name or + // a primitive op's name. func.attr.first is the name of an attr + // defined for that function. func.attr.second is the value for + // that attr in the instantiation. + NameAttrList func = 10; + + // This is a placeholder only used in nodes defined inside a + // function. It indicates the attr value will be supplied when + // the function is instantiated. For example, let us suppose a + // node "N" in function "FN". "N" has an attr "A" with value + // placeholder = "foo". When FN is instantiated with attr "foo" + // set to "bar", the instantiated node N's attr A will have been + // given the value "bar". + string placeholder = 9; + } +} + +// A list of attr names and their values. The whole list is attached +// with a string name. E.g., MatMul[T=float]. +message NameAttrList { + string name = 1; + map attr = 2; +} diff --git a/modules/dnn/src/tensorflow/function.proto b/modules/dnn/src/tensorflow/function.proto new file mode 100644 index 0000000000..144c75bf32 --- /dev/null +++ b/modules/dnn/src/tensorflow/function.proto @@ -0,0 +1,95 @@ +syntax = "proto3"; + +package tensorflow; +option cc_enable_arenas = true; +option java_outer_classname = "FunctionProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +import "attr_value.proto"; +import "op_def.proto"; + +// A library is a set of named functions. +message FunctionDefLibrary { + repeated FunctionDef function = 1; + repeated GradientDef gradient = 2; +} + +// A function can be instantiated when the runtime can bind every attr +// with a value. When a GraphDef has a call to a function, it must +// have binding for every attr defined in the signature. +// +// TODO(zhifengc): +// * device spec, etc. +message FunctionDef { + // The definition of the function's name, arguments, return values, + // attrs etc. + OpDef signature = 1; + + // The body of the function. + repeated Node node = 2; // function.node.ret[*] are unique. + + // A node is a multi-value assignment: + // (ret[0], ret[1], ...) = func(arg[0], arg[1], ...) + // + // By convention, "func" is resolved by consulting with a user-defined + // library first. If not resolved, "func" is assumed to be a builtin op. + message Node { + // This node produces multiple outputs. They are named ret[0], + // ret[1], ..., etc. + // + // REQUIRES: function.node.ret[*] are unique across all nodes. + // REQUIRES: ret.size == func/op def's number of output args. + repeated string ret = 1; + + // The op/function name. + string op = 2; + + // Arguments passed to this func/op. + // + // arg[i] must be either one of + // function.signature.input_args[*].name or one of + // function.node[*].ret[*]. + // + // REQUIRES: arg.size == func/op def's number of input args. + repeated string arg = 3; + + // Control dependencies. + // + // dep[i] must be one of function.node[*].ret[*] or one of + // function.signature.input_args[*].name. + repeated string dep = 4; + + // Attrs. + // + // 'attr' maps names defined by 'func's attr defs to attr values. + // attr values may have placeholders which are substituted + // recursively by concrete values when this node is instantiated. + // These placeholders must name an attr listed in the FunctionDef's + // signature. + map attr = 5; + } +} + +// GradientDef defines the gradient function of a function defined in +// a function library. +// +// A gradient function g (specified by gradient_func) for a function f +// (specified by function_name) must follow the following: +// +// The function 'f' must be a numerical function which takes N inputs +// and produces M outputs. Its gradient function 'g', which is a +// function taking N + M inputs and produces N outputs. +// +// I.e. if we have +// (y1, y2, ..., y_M) = f(x1, x2, ..., x_N), +// then, g is +// (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N, +// dL/dy1, dL/dy2, ..., dL/dy_M), +// where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the +// loss function). dL/dx_i is the partial derivative of L with respect +// to x_i. +message GradientDef { + string function_name = 1; // The function name. + string gradient_func = 2; // The gradient function's name. +} diff --git a/modules/dnn/src/tensorflow/graph.proto b/modules/dnn/src/tensorflow/graph.proto new file mode 100644 index 0000000000..f945201399 --- /dev/null +++ b/modules/dnn/src/tensorflow/graph.proto @@ -0,0 +1,112 @@ +syntax = "proto3"; + +package tensorflow; +option cc_enable_arenas = true; +option java_outer_classname = "GraphProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +import "attr_value.proto"; +import "function.proto"; +import "versions.proto"; + +// Represents the graph of operations +message GraphDef { + repeated NodeDef node = 1; + + // Compatibility versions of the graph. See core/public/version.h for version + // history. The GraphDef version is distinct from the TensorFlow version, and + // each release of TensorFlow will support a range of GraphDef versions. + VersionDef versions = 4; + + // Deprecated single version field; use versions above instead. Since all + // GraphDef changes before "versions" was introduced were forward + // compatible, this field is entirely ignored. + int32 version = 3 [deprecated = true]; + + // EXPERIMENTAL. DO NOT USE OR DEPEND ON THIS YET. + // + // "library" provides user-defined functions. + // + // Naming: + // * library.function.name are in a flat namespace. + // NOTE: We may need to change it to be hierarchical to support + // different orgs. E.g., + // { "/google/nn", { ... }}, + // { "/google/vision", { ... }} + // { "/org_foo/module_bar", {...}} + // map named_lib; + // * If node[i].op is the name of one function in "library", + // node[i] is deemed as a function call. Otherwise, node[i].op + // must be a primitive operation supported by the runtime. + // + // + // Function call semantics: + // + // * The callee may start execution as soon as some of its inputs + // are ready. The caller may want to use Tuple() mechanism to + // ensure all inputs are ready in the same time. + // + // * The consumer of return values may start executing as soon as + // the return values the consumer depends on are ready. The + // consumer may want to use Tuple() mechanism to ensure the + // consumer does not start until all return values of the callee + // function are ready. + FunctionDefLibrary library = 2; +}; + +message NodeDef { + // The name given to this operator. Used for naming inputs, + // logging, visualization, etc. Unique within a single GraphDef. + // Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_./]*". + string name = 1; + + // The operation name. There may be custom parameters in attrs. + // Op names starting with an underscore are reserved for internal use. + string op = 2; + + // Each input is "node:src_output" with "node" being a string name and + // "src_output" indicating which output tensor to use from "node". If + // "src_output" is 0 the ":0" suffix can be omitted. Regular inputs + // may optionally be followed by control inputs that have the format + // "^node". + repeated string input = 3; + + // A (possibly partial) specification for the device on which this + // node should be placed. + // The expected syntax for this string is as follows: + // + // DEVICE_SPEC ::= COLOCATED_NODE | PARTIAL_SPEC + // + // COLOCATED_NODE ::= "@" NODE_NAME // See NodeDef.name above. + // PARTIAL_SPEC ::= ("/" CONSTRAINT) * + // CONSTRAINT ::= ("job:" JOB_NAME) + // | ("replica:" [1-9][0-9]*) + // | ("task:" [1-9][0-9]*) + // | ( ("gpu" | "cpu") ":" ([1-9][0-9]* | "*") ) + // + // Valid values for this string include: + // * "@other/node" (colocate with "other/node") + // * "/job:worker/replica:0/task:1/gpu:3" (full specification) + // * "/job:worker/gpu:3" (partial specification) + // * "" (no specification) + // + // If the constraints do not resolve to a single device (or if this + // field is empty or not present), the runtime will attempt to + // choose a device automatically. + string device = 4; + + // Operation-specific graph-construction-time configuration. + // Note that this should include all attrs defined in the + // corresponding OpDef, including those with a value matching + // the default -- this allows the default to change and makes + // NodeDefs easier to interpret on their own. However, if + // an attr with a default is not specified in this list, the + // default will be used. + // The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and + // one of the names from the corresponding OpDef's attr field). + // The values must have a type matching the corresponding OpDef + // attr's type field. + // TODO(josh11b): Add some examples here showing best practices. + map attr = 5; +}; diff --git a/modules/dnn/src/tensorflow/op_def.proto b/modules/dnn/src/tensorflow/op_def.proto new file mode 100644 index 0000000000..baf68eaad3 --- /dev/null +++ b/modules/dnn/src/tensorflow/op_def.proto @@ -0,0 +1,157 @@ +syntax = "proto3"; + +package tensorflow; +option cc_enable_arenas = true; +option java_outer_classname = "OpDefProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +import "attr_value.proto"; +import "types.proto"; + +// Defines an operation. A NodeDef in a GraphDef specifies an Op by +// using the "op" field which should match the name of a OpDef. +message OpDef { + // Op names starting with an underscore are reserved for internal use. + // Names should be CamelCase and match the regexp "[A-Z][a-zA-Z0-9_]*". + string name = 1; + + // For describing inputs and outputs. + message ArgDef { + // Name for the input/output. Should match the regexp "[a-z][a-z0-9_]*". + string name = 1; + + // Human readable description. + string description = 2; + + // Describes the type of one or more tensors that are accepted/produced + // by this input/output arg. The only legal combinations are: + // * For a single tensor: either the "type" field is set or the + // "type_attr" field is set to the name of an attr with type "type". + // * For a sequence of tensors with the same type: the "number_attr" + // field will be set to the name of an attr with type "int", and + // either the "type" or "type_attr" field will be set as for + // single tensors. + // * For a sequence of tensors, the "type_list_attr" field will be set + // to the name of an attr with type "list(type)". + DataType type = 3; + string type_attr = 4; // if specified, attr must have type "type" + string number_attr = 5; // if specified, attr must have type "int" + // If specified, attr must have type "list(type)", and none of + // type, type_attr, and number_attr may be specified. + string type_list_attr = 6; + + // For inputs: if true, the inputs are required to be refs. + // By default, inputs can be either refs or non-refs. + // For outputs: if true, outputs are refs, otherwise they are not. + bool is_ref = 16; + }; + + // Description of the input(s). + repeated ArgDef input_arg = 2; + + // Description of the output(s). + repeated ArgDef output_arg = 3; + + // Description of the graph-construction-time configuration of this + // Op. That is to say, this describes the attr fields that will + // be specified in the NodeDef. + message AttrDef { + // A descriptive name for the argument. May be used, e.g. by the + // Python client, as a keyword argument name, and so should match + // the regexp "[a-z][a-z0-9_]+". + string name = 1; + + // One of the type names from attr_value.proto ("string", "list(string)", + // "int", etc.). + string type = 2; + + // A reasonable default for this attribute if the user does not supply + // a value. If not specified, the user must supply a value. + AttrValue default_value = 3; + + // Human-readable description. + string description = 4; + + // TODO(josh11b): bool is_optional? + + // --- Constraints --- + // These constraints are only in effect if specified. Default is no + // constraints. + + // For type == "int", this is a minimum value. For "list(___)" + // types, this is the minimum length. + bool has_minimum = 5; + int64 minimum = 6; + + // The set of allowed values. Has type that is the "list" version + // of the "type" field above (uses the "list" field of AttrValue). + // If type == "type" or "list(type)" above, then the "type" field + // of "allowed_values.list" has the set of allowed DataTypes. + // If type == "string" or "list(string)", then the "s" field of + // "allowed_values.list" has the set of allowed strings. + AttrValue allowed_values = 7; + } + repeated AttrDef attr = 4; + + // Optional deprecation based on GraphDef versions. + OpDeprecation deprecation = 8; + + // One-line human-readable description of what the Op does. + string summary = 5; + + // Additional, longer human-readable description of what the Op does. + string description = 6; + + // ------------------------------------------------------------------------- + // Which optimizations this operation can participate in. + + // True if the operation is commutative ("op(a,b) == op(b,a)" for all inputs) + bool is_commutative = 18; + + // If is_aggregate is true, then this operation accepts N >= 2 + // inputs and produces 1 output all of the same type. Should be + // associative and commutative, and produce output with the same + // shape as the input. The optimizer may replace an aggregate op + // taking input from multiple devices with a tree of aggregate ops + // that aggregate locally within each device (and possibly within + // groups of nearby devices) before communicating. + // TODO(josh11b): Implement that optimization. + bool is_aggregate = 16; // for things like add + + // Other optimizations go here, like + // can_alias_input, rewrite_when_output_unused, partitioning_strategy, etc. + + // ------------------------------------------------------------------------- + // Optimization constraints. + + // By default Ops may be moved between devices. Stateful ops should + // either not be moved, or should only be moved if that state can also + // be moved (e.g. via some sort of save / restore). + // Stateful ops are guaranteed to never be optimized away by Common + // Subexpression Elimination (CSE). + bool is_stateful = 17; // for things like variables, queue + + // ------------------------------------------------------------------------- + // Non-standard options. + + // By default, all inputs to an Op must be initialized Tensors. Ops + // that may initialize tensors for the first time should set this + // field to true, to allow the Op to take an uninitialized Tensor as + // input. + bool allows_uninitialized_input = 19; // for Assign, etc. +}; + +// Information about version-dependent deprecation of an op +message OpDeprecation { + // First GraphDef version at which the op is disallowed. + int32 version = 1; + + // Explanation of why it was deprecated and what to use instead. + string explanation = 2; +}; + +// A collection of OpDefs +message OpList { + repeated OpDef op = 1; +}; diff --git a/modules/dnn/src/tensorflow/tensor.proto b/modules/dnn/src/tensorflow/tensor.proto new file mode 100644 index 0000000000..080421809e --- /dev/null +++ b/modules/dnn/src/tensorflow/tensor.proto @@ -0,0 +1,68 @@ +syntax = "proto3"; + +package tensorflow; +option cc_enable_arenas = true; +option java_outer_classname = "TensorProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +import "tensor_shape.proto"; +import "types.proto"; + +// Protocol buffer representing a tensor. +message TensorProto { + DataType dtype = 1; + + // Shape of the tensor. TODO(touts): sort out the 0-rank issues. + TensorShapeProto tensor_shape = 2; + + // Only one of the representations below is set, one of "tensor_contents" and + // the "xxx_val" attributes. We are not using oneof because as oneofs cannot + // contain repeated fields it would require another extra set of messages. + + // Version number. + // + // In version 0, if the "repeated xxx" representations contain only one + // element, that element is repeated to fill the shape. This makes it easy + // to represent a constant Tensor with a single value. + int32 version_number = 3; + + // Serialized content from Tensor::AsProtoTensorContent(). This representation + // can be used for all tensor types. + bytes tensor_content = 4; + + // Type specific representations that make it easy to create tensor protos in + // all languages. Only the representation corresponding to "dtype" can + // be set. The values hold the flattened representation of the tensor in + // row major order. + + // DT_HALF. Note that since protobuf has no int16 type, we'll have some + // pointless zero padding for each value here. + repeated int32 half_val = 13 [packed = true]; + + // DT_FLOAT. + repeated float float_val = 5 [packed = true]; + + // DT_DOUBLE. + repeated double double_val = 6 [packed = true]; + + // DT_INT32, DT_INT16, DT_INT8, DT_UINT8. + repeated int32 int_val = 7 [packed = true]; + + // DT_STRING + repeated bytes string_val = 8; + + // DT_COMPLEX64. scomplex_val(2*i) and scomplex_val(2*i+1) are real + // and imaginary parts of i-th single precision complex. + repeated float scomplex_val = 9 [packed = true]; + + // DT_INT64 + repeated int64 int64_val = 10 [packed = true]; + + // DT_BOOL + repeated bool bool_val = 11 [packed = true]; + + // DT_COMPLEX128. dcomplex_val(2*i) and dcomplex_val(2*i+1) are real + // and imaginary parts of i-th double precision complex. + repeated double dcomplex_val = 12 [packed = true]; +}; diff --git a/modules/dnn/src/tensorflow/tensor_shape.proto b/modules/dnn/src/tensorflow/tensor_shape.proto new file mode 100644 index 0000000000..1ec3c5323c --- /dev/null +++ b/modules/dnn/src/tensorflow/tensor_shape.proto @@ -0,0 +1,45 @@ +// Protocol buffer representing the shape of tensors. + +syntax = "proto3"; +option cc_enable_arenas = true; +option java_outer_classname = "TensorShapeProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +package tensorflow; + +// Dimensions of a tensor. +message TensorShapeProto { + // One dimension of the tensor. + message Dim { + // Size of the tensor in that dimension. + // This value must be >= -1, but values of -1 are reserved for "unknown" + // shapes (values of -1 mean "unknown" dimension). Certain wrappers + // that work with TensorShapeProto may fail at runtime when deserializing + // a TensorShapeProto containing a dim value of -1. + int64 size = 1; + + // Optional name of the tensor dimension. + string name = 2; + }; + + // Dimensions of the tensor, such as {"input", 30}, {"output", 40} + // for a 30 x 40 2D tensor. If an entry has size -1, this + // corresponds to a dimension of unknown size. The names are + // optional. + // + // The order of entries in "dim" matters: It indicates the layout of the + // values in the tensor in-memory representation. + // + // The first entry in "dim" is the outermost dimension used to layout the + // values, the last entry is the innermost dimension. This matches the + // in-memory layout of RowMajor Eigen tensors. + // + // If "dim.size()" > 0, "unknown_rank" must be false. + repeated Dim dim = 2; + + // If true, the number of dimensions in the shape is unknown. + // + // If true, "dim.size()" must be 0. + bool unknown_rank = 3; +}; diff --git a/modules/dnn/src/tensorflow/tf_importer.cpp b/modules/dnn/src/tensorflow/tf_importer.cpp new file mode 100644 index 0000000000..0ff2dd3b5d --- /dev/null +++ b/modules/dnn/src/tensorflow/tf_importer.cpp @@ -0,0 +1,759 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Implementation of Tensorflow models parser +*/ + +#include "../precomp.hpp" +using namespace cv; +using namespace cv::dnn; + +#if HAVE_PROTOBUF +#include "graph.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include "tf_io.hpp" + +using ::google::protobuf::RepeatedField; +using ::google::protobuf::RepeatedPtrField; +using ::google::protobuf::Message; +using ::google::protobuf::Descriptor; +using ::google::protobuf::FieldDescriptor; +using ::google::protobuf::Reflection; + +namespace +{ + +static int toNCHW[] = {0, 2, 3, 1}; + +typedef std::vector > StrIntVector; + +struct Pin +{ + Pin(const std::string &_name, int _blobIndex = 0) : + name(_name), blobIndex(_blobIndex) {} + + Pin() : + name(""), blobIndex(-1) {} + + std::string name; + int blobIndex; +}; + +void blobShapeFromTensor(const tensorflow::TensorProto &tensor, MatShape& shape) +{ + shape.clear(); + if (tensor.has_tensor_shape()) + { + const tensorflow::TensorShapeProto &_shape = tensor.tensor_shape(); + int i, n = _shape.dim_size(); + shape.resize(n); + + for (i = 0; i < n; i++) + shape[i] = (int)_shape.dim(i).size(); + } + else + { + CV_Error(Error::StsError, "Unknown shape of input tensor"); + } +} + +template +void parseTensor(const tensorflow::TensorProto &tensor, Mat &dstBlob) +{ + MatShape shape; + blobShapeFromTensor(tensor, shape); + int dims = (int)shape.size(); + + if (dims == 4) + { + // REORDER blob NHWC to NCHW + swap(shape[2], shape[3]); // NHCW + swap(shape[1], shape[2]); // NCHW + } + + dstBlob.create(shape, CV_32F); + + int size = tensor.tensor_content().size() / sizeof(T); + CV_Assert(size == (int)dstBlob.total()); + + float *dstData = dstBlob.ptr(); + const T *data = reinterpret_cast(tensor.tensor_content().c_str()); + + if (dims == 4) + { + int num = shape[0], channels = shape[1], height = shape[2], width = shape[3]; + int total = num*channels*height*width; + for(int i_n = 0; i_n < shape[0]; i_n++) { + for(int i_c = 0; i_c < shape[1]; i_c++) { + for(int i_h = 0; i_h < shape[2]; i_h++) { + for(int i_w = 0; i_w < shape[3]; i_w++) { + int dst_i = channels*height*width*i_n + height*width*i_c + width*i_h + i_w; + int src_i = channels*height*width*i_n + i_c + channels*width*i_h + channels*i_w; + + CV_Assert(dst_i < total); + CV_Assert(src_i < total); + + dstData[dst_i] = data[src_i]; + } + } + } + } + } else { + for (int i = 0; i < size; i++) + dstData[i] = data[i]; + } +} + +void blobFromTensor(const tensorflow::TensorProto &tensor, Mat &dstBlob) +{ + switch (tensor.dtype()) { + case tensorflow::DT_FLOAT: + parseTensor(tensor, dstBlob); + break; + case tensorflow::DT_DOUBLE: + parseTensor(tensor, dstBlob); + break; + default: + CV_Error(Error::StsError, "Tensor's data type is not supported"); + break; + } +} + +void printList(const tensorflow::AttrValue::ListValue &val) +{ + std::cout << "("; + for (int i = 0; i < val.i_size(); i++) + std::cout << " " << val.i(i); + std::cout << " )"; +} + +void printTensorShape(const tensorflow::TensorShapeProto &shape) +{ + std::cout << "[ "; + for (int d = 0; d < shape.dim_size(); d++) + std::cout << shape.dim(d).name() << + ":" << shape.dim(d).size() << " "; + std::cout << "]"; +} + +void printTensor(const tensorflow::TensorProto &tensor) +{ + printTensorShape(tensor.tensor_shape()); + + if (tensor.tensor_content().empty()) + return; + + switch (tensor.dtype()) + { + case 1: // float + { + const float *data = reinterpret_cast(tensor.tensor_content().c_str()); + int size = tensor.tensor_content().size() / sizeof(float); + for (int i = 0; i < std::min(10, size); i++) + std::cout << " " << data[i]; + if (size > 10) + std::cout << " ... " << size - 10 << " more"; + break; + } + case 3: // int32 + { + const int *data = reinterpret_cast(tensor.tensor_content().c_str()); + int size = tensor.tensor_content().size() / sizeof(int); + for (int i = 0; i < std::min(10, size); i++) + std::cout << " " << data[i]; + if (size > 10) + std::cout << " ... " << size - 10 << " more"; + break; + } + default: + CV_Error(Error::StsError, "Tensor type is not supported"); + break; + } +} + +void printLayerAttr(const tensorflow::NodeDef &layer) +{ + std::cout << std::endl << layer.name() << ":" << layer.op(); + for (int ii = 0; ii < layer.input_size(); ii++) + std::cout << "(" << layer.input(ii) << ")"; + std::cout << std::endl; + google::protobuf::Map attr + = layer.attr(); + for (google::protobuf::Map::const_iterator ai = attr.begin(); + ai != attr.end(); ++ai) + { + std::cout << ai->first << ":"; + if (ai->first == "dtype" || ai->first == "T") + std::cout << ai->second.i(); + else if (ai->first == "padding") + std::cout << ai->second.s(); + else if (ai->first == "transpose_a" || ai->first == "transpose_b") + std::cout << ai->second.b(); + // else if (ai->first == "shape") + // printTensorShape(ai->second.shape()); + else if (ai->first == "strides" || ai->first == "ksize") + printList(ai->second.list()); + else + printTensor(ai->second.tensor()); + std::cout << std::endl; + } +} + +bool hasLayerAttr(const tensorflow::NodeDef &layer, const std::string &name) +{ + google::protobuf::Map attr = layer.attr(); + return attr.find(name) != attr.end(); +} + +const tensorflow::AttrValue& getLayerAttr(const tensorflow::NodeDef &layer, const std::string &name) +{ + return layer.attr().at(name); +} + +void setStrides(LayerParams &layerParams, const tensorflow::NodeDef &layer) +{ + if (hasLayerAttr(layer, "strides")) + { + const tensorflow::AttrValue& val = getLayerAttr(layer, "strides"); + if (val.list().i_size() != 4 || + val.list().i(0) != 1 || val.list().i(3) != 1) + CV_Error(Error::StsError, "Unsupported strides"); + layerParams.set("stride_h", static_cast(val.list().i(1))); + layerParams.set("stride_w", static_cast(val.list().i(2))); + } +} + +DictValue parseDims(const tensorflow::TensorProto &tensor) { + MatShape shape; + blobShapeFromTensor(tensor, shape); + int dims = (int)shape.size(); + + CV_Assert(tensor.dtype() == tensorflow::DT_INT32); + CV_Assert(dims == 1); + + int size = tensor.tensor_content().size() / sizeof(int); + const int *data = reinterpret_cast(tensor.tensor_content().c_str()); + // TODO: add reordering shape if dims == 4 + return DictValue::arrayInt(data, size); +} + +void setKSize(LayerParams &layerParams, const tensorflow::NodeDef &layer) +{ + if (hasLayerAttr(layer, "ksize")) + { + const tensorflow::AttrValue& val = getLayerAttr(layer, "ksize"); + if (val.list().i_size() != 4 || + val.list().i(0) != 1 || val.list().i(3) != 1) + CV_Error(Error::StsError, "Unsupported ksize"); + layerParams.set("kernel_h", static_cast(val.list().i(1))); + layerParams.set("kernel_w", static_cast(val.list().i(2))); + } + else + { + layerParams.set("kernel_h", 1); + layerParams.set("kernel_w", 1); + } +} + +void setPadding(LayerParams &layerParams, const tensorflow::NodeDef &layer) +{ + if (hasLayerAttr(layer, "padding")) + layerParams.set("pad_mode", getLayerAttr(layer, "padding").s()); +} + +void RemoveIdentityOps(tensorflow::GraphDef& net) { + typedef std::map IdentityOpsMap; + IdentityOpsMap identity_ops; + + std::vector identity_ops_idx; + + int layersCount = net.node_size(); + for (int li = 0; li < layersCount; li++) + { + const tensorflow::NodeDef &layer = net.node(li); + String type = layer.op(); + + if (type == "Identity") { + identity_ops_idx.push_back(li); + identity_ops[layer.name()] = layer.input(0); + } + } + + for (int li = 0; li < layersCount; li++) + { + tensorflow::NodeDef* layer = net.mutable_node(li); + for (int input_id = 0; input_id < layer->input_size(); input_id++) { + String input_op_name = layer->input(input_id); + IdentityOpsMap::iterator it = identity_ops.find(input_op_name); + + if (it != identity_ops.end()) { + layer->set_input(input_id, it->second); + } + } + } + + std::sort(identity_ops_idx.begin(), identity_ops_idx.end()); + + int removed_nodes = 0; + for(size_t i = 0; i < identity_ops_idx.size(); i++) { + int start_id = identity_ops_idx[i] - removed_nodes; + net.mutable_node()->DeleteSubrange(start_id, 1); + removed_nodes++; + } +} + +Pin parsePin(const std::string &name) +{ + Pin pin(name); + + size_t delimiter_pos = name.find_first_of(":"); + if (delimiter_pos != std::string::npos) + { + pin.name = name.substr(0, delimiter_pos); + std::istringstream(name.substr(delimiter_pos + 1)) >> pin.blobIndex; + } + + return pin; +} + +StrIntVector getNextLayers(const tensorflow::GraphDef& net, const String& layer_name, const String& type = "") +{ + StrIntVector layers; + + for (int li = 0; li < net.node_size(); li++) + { + const tensorflow::NodeDef& layer = net.node(li); + for (int input_id = 0; input_id < layer.input_size(); input_id++) { + String input_op_name = parsePin(layer.input(input_id)).name; + bool type_ok = type.empty() ? true : type == layer.op(); + if (input_op_name == layer_name && type_ok) + layers.push_back(std::make_pair(layer.name(), li)); + } + } + + return layers; +} + +void ExcludeLayer(tensorflow::GraphDef& net, const int layer_index, const int input_blob_index, bool remove_from_net = true) { + String layer_name = net.node(layer_index).name(); + StrIntVector layers = getNextLayers(net, layer_name); + + String removed_layer_input = net.node(layer_index).input(input_blob_index); + + for (size_t i = 0; i < layers.size(); i++) + { + tensorflow::NodeDef* layer = net.mutable_node(layers[i].second); + for (int input_id = 0; input_id < layer->input_size(); input_id++) { + String input_op_name = layer->input(input_id); + + if (input_op_name == layer_name) { + layer->set_input(input_id, removed_layer_input); + } + } + } + + if (remove_from_net) + net.mutable_node()->DeleteSubrange(layer_index, 1); +} + +class TFImporter : public Importer { +public: + TFImporter(const char *model); + void populateNet(Net dstNet); + ~TFImporter() {} + +private: + void kernelFromTensor(const tensorflow::TensorProto &tensor, Mat &dstBlob); + + void connect(const std::map& layers_name_id_map, Net& network, const Pin& outPin, + const int input_layer_id, const int input_blob_id); + void connectToAllBlobs(const std::map& layer_id, Net& network, const Pin& outPin, + const int input_layer_id, const int input_blobs_count); + const tensorflow::TensorProto& getConstBlob(const tensorflow::NodeDef &layer, std::map const_layers, + int input_blob_index = -1, int* actual_inp_blob_idx = 0); + + + tensorflow::GraphDef net; +}; + +TFImporter::TFImporter(const char *model) +{ + if (model && model[0]) + ReadTFNetParamsFromBinaryFileOrDie(model, &net); +} + +void TFImporter::kernelFromTensor(const tensorflow::TensorProto &tensor, Mat &dstBlob) +{ + MatShape shape; + blobShapeFromTensor(tensor, shape); + int dims = (int)shape.size(); + + // TODO: other blob types + CV_Assert(tensor.dtype() == tensorflow::DT_FLOAT); + CV_Assert(dims == 4); + + // REORDER kernel HWIO to OIHW + swap(shape[0], shape[2]); // IWHO + swap(shape[1], shape[3]); // IOHW + swap(shape[0], shape[1]); // OIHW + + dstBlob.create(shape, CV_32F); + + int size = tensor.tensor_content().size() / sizeof(float); + CV_Assert(size == (int)dstBlob.total()); + + float *dstData = dstBlob.ptr(); + const float *data = reinterpret_cast(tensor.tensor_content().c_str()); + + int out_c = shape[0], input_c = shape[1], height = shape[2], width = shape[3]; + int total = out_c*input_c*height*width; + for(int i_oc = 0; i_oc < out_c; i_oc++) { + for(int i_ic = 0; i_ic < input_c; i_ic++) { + for(int i_h = 0; i_h < height; i_h++) { + for(int i_w = 0; i_w < width; i_w++) { + int dst_i = input_c*height*width*i_oc + height*width*i_ic + width*i_h + i_w; + int src_i = out_c*input_c*width*i_h + out_c*input_c*i_w + out_c*i_ic + i_oc; + CV_Assert(dst_i < total); + CV_Assert(src_i < total); + dstData[dst_i] = data[src_i]; + } + } + } + } +} + +void TFImporter::connect(const std::map& layers_name_id_map, Net& network, const Pin& outPin, + const int input_layer_id, const int input_blob_id) +{ + std::map::const_iterator it = layers_name_id_map.find(outPin.name); + if (it == layers_name_id_map.end()) + CV_Error(Error::StsError, "Input layer not found: " + outPin.name); + network.connect(it->second, outPin.blobIndex, input_layer_id, input_blob_id); +} + +void TFImporter::connectToAllBlobs(const std::map& layer_id, Net& network, const Pin& outPin, + const int input_layer_id, const int input_blobs_count) +{ + for (int input_blob_id = 0; input_blob_id < input_blobs_count; input_blob_id++) + connect(layer_id, network, outPin, input_layer_id, input_blob_id); +} + +const tensorflow::TensorProto& TFImporter::getConstBlob(const tensorflow::NodeDef &layer, std::map const_layers, + int input_blob_index, int* actual_inp_blob_idx) { + if (input_blob_index == -1) { + for(int i = 0; i < layer.input_size(); i++) { + Pin input = parsePin(layer.input(i)); + if (const_layers.find(input.name) != const_layers.end()) { + if (input_blob_index != -1) + CV_Error(Error::StsError, "More than one input is Const op"); + + input_blob_index = i; + } + } + } + + if (input_blob_index == -1) + CV_Error(Error::StsError, "Const input blob for weights not found"); + + Pin kernel_inp = parsePin(layer.input(input_blob_index)); + if (const_layers.find(kernel_inp.name) == const_layers.end()) + CV_Error(Error::StsError, "Const kernel input not found"); + if (kernel_inp.blobIndex != 0) + CV_Error(Error::StsError, "Unsupported kernel input"); + + if(actual_inp_blob_idx) { + *actual_inp_blob_idx = input_blob_index; + } + + return net.node(const_layers.at(kernel_inp.name)).attr().at("value").tensor(); +} + + +void TFImporter::populateNet(Net dstNet) +{ + RemoveIdentityOps(net); + + std::map layers_to_ignore; + + int layersSize = net.node_size(); + + // find all Const layers for params + std::map value_id; + for (int li = 0; li < layersSize; li++) + { + const tensorflow::NodeDef &layer = net.node(li); + String name = layer.name(); + String type = layer.op(); + + if (type != "Const") + continue; // only Const parameters are supported + + if (layer.attr().find("value") != layer.attr().end()) + { + value_id.insert(std::make_pair(name, li)); + } + + layers_to_ignore[li] = name; + } + + std::map layer_id; + + for (int li = 0; li < layersSize; li++) + { + const tensorflow::NodeDef &layer = net.node(li); + String name = layer.name(); + String type = layer.op(); + LayerParams layerParams; + + if(layers_to_ignore.find(li) != layers_to_ignore.end()) + continue; + + if (type == "Conv2D") + { + layerParams.set("bias_term", false); + layerParams.blobs.resize(1); + + StrIntVector next_layers = getNextLayers(net, name, "BiasAdd"); + if (next_layers.size() == 1) { + layerParams.set("bias_term", true); + layerParams.blobs.resize(2); + + int weights_layer_index = next_layers[0].second; + + blobFromTensor(getConstBlob(net.node(weights_layer_index), value_id), layerParams.blobs[1]); + ExcludeLayer(net, weights_layer_index, 0, false); + layers_to_ignore[weights_layer_index] = next_layers[0].first; + } + + kernelFromTensor(getConstBlob(layer, value_id), layerParams.blobs[0]); + const int* kshape = layerParams.blobs[0].size.p; + layerParams.set("kernel_h", kshape[2]); + layerParams.set("kernel_w", kshape[3]); + layerParams.set("num_output", kshape[0]); + + setStrides(layerParams, layer); + setPadding(layerParams, layer); + + int id = dstNet.addLayer(name, "Convolution", layerParams); + layer_id[name] = id; + + // one input only + connect(layer_id, dstNet, parsePin(layer.input(0)), id, 0); + } + else if (type == "BiasAdd" || type == "Add") + { + layerParams.blobs.resize(1); + blobFromTensor(getConstBlob(layer, value_id), layerParams.blobs[0]); + + int id = dstNet.addLayer(name, "Shift", layerParams); + layer_id[name] = id; + + // one input only + connect(layer_id, dstNet, parsePin(layer.input(0)), id, 0); + } + else if (type == "Identity") + { + int id = dstNet.addLayer(name, "Identity", layerParams); + layer_id[name] = id; + + connectToAllBlobs(layer_id, dstNet, parsePin(layer.input(0)), id, layer.input_size()); + } + else if (type == "MatMul") + { + CV_Assert(layer.input_size() == 2); + + layerParams.set("bias_term", false); + layerParams.blobs.resize(1); + + StrIntVector next_layers = getNextLayers(net, name, "BiasAdd"); + if (next_layers.size() == 1) { + layerParams.set("bias_term", true); + layerParams.blobs.resize(2); + + int weights_layer_index = next_layers[0].second; + blobFromTensor(getConstBlob(net.node(weights_layer_index), value_id), layerParams.blobs[1]); + ExcludeLayer(net, weights_layer_index, 0, false); + layers_to_ignore[weights_layer_index] = next_layers[0].first; + } + + int kernel_blob_index = -1; + blobFromTensor(getConstBlob(layer, value_id, -1, &kernel_blob_index), layerParams.blobs[0]); + + if (kernel_blob_index == 1) { // In this case output is computed by x*W formula - W should be transposed + Mat data = layerParams.blobs[0].t(); + layerParams.blobs[0] = data.clone(); + } + + layerParams.set("num_output", layerParams.blobs[0].size[0]); + + int id = dstNet.addLayer(name, "InnerProduct", layerParams); + layer_id[name] = id; + + // one input only + int input_blob_index = kernel_blob_index == 0 ? 1 : 0; + connect(layer_id, dstNet, parsePin(layer.input(input_blob_index)), id, 0); + } + else if (type == "Reshape") + { + layerParams.set("dim", parseDims(getConstBlob(layer, value_id, 1))); + layerParams.set("reorder_dims", true); + + int id = dstNet.addLayer(name, "Reshape", layerParams); + layer_id[name] = id; + + // one input only + connect(layer_id, dstNet, parsePin(layer.input(0)), id, 0); + } + else if (type == "Const") + { + } + else if (type == "Softmax") + { + int id = dstNet.addLayer(name, "Softmax", layerParams); + layer_id[name] = id; + + connectToAllBlobs(layer_id, dstNet, parsePin(layer.input(0)), id, layer.input_size()); + } + else if (type == "LRN") + { + if(hasLayerAttr(layer, "alpha")) { + layerParams.set("alpha", getLayerAttr(layer, "alpha").f()); + } + if(hasLayerAttr(layer, "beta")) { + layerParams.set("beta", getLayerAttr(layer, "beta").f()); + } + if(hasLayerAttr(layer, "depth_radius")) { + int radius = (int)getLayerAttr(layer, "depth_radius").i(); + layerParams.set("local_size", 2*radius + 1); + } + if(hasLayerAttr(layer, "bias")) { + layerParams.set("bias", getLayerAttr(layer, "bias").f()); + } + layerParams.set("norm_by_size", false); + + int id = dstNet.addLayer(name, "LRN", layerParams); + layer_id[name] = id; + + connectToAllBlobs(layer_id, dstNet, parsePin(layer.input(0)), id, layer.input_size()); + } + else if (type == "Concat") + { + int axis = getConstBlob(layer, value_id, 0).int_val().Get(0); + layerParams.set("axis", toNCHW[axis]); + + int id = dstNet.addLayer(name, "Concat", layerParams); + layer_id[name] = id; + + // input(0) is concat_dim + for (int ii = 1; ii < layer.input_size(); ii++) + { + Pin inp = parsePin(layer.input(ii)); + if (layer_id.find(inp.name) == layer_id.end()) + CV_Error(Error::StsError, "Input layer not found: " + inp.name); + dstNet.connect(layer_id.at(inp.name), inp.blobIndex, id, ii - 1); + } + } + else if (type == "Relu") + { + int id = dstNet.addLayer(name, "ReLU", layerParams); + layer_id[name] = id; + + connectToAllBlobs(layer_id, dstNet, parsePin(layer.input(0)), id, layer.input_size()); + } + else if (type == "MaxPool") + { + layerParams.set("pool", "max"); + + setKSize(layerParams, layer); + setStrides(layerParams, layer); + setPadding(layerParams, layer); + + int id = dstNet.addLayer(name, "Pooling", layerParams); + layer_id[name] = id; + + connectToAllBlobs(layer_id, dstNet, parsePin(layer.input(0)), id, layer.input_size()); + } + else if (type == "AvgPool") + { + layerParams.set("pool", "ave"); + + setKSize(layerParams, layer); + setStrides(layerParams, layer); + setPadding(layerParams, layer); + + int id = dstNet.addLayer(name, "Pooling", layerParams); + layer_id[name] = id; + + connectToAllBlobs(layer_id, dstNet, parsePin(layer.input(0)), id, layer.input_size()); + } + else if (type == "Placeholder") + { + std::vector netInputs(1); + netInputs[0] = name; + layer_id[name] = 0; + dstNet.setInputsNames(netInputs); + } + else if (type == "Split") { + // TODO: determing axis index remapping by input dimensions order of input blob + // TODO: slicing input may be Const op + // TODO: slicing kernels for convolutions - in current implenmentation it is impossible + // TODO: add parsing num of slices parameter + CV_Assert(layer.input_size() == 2); + // num_split + // 1st blob is dims tensor + layerParams.set("slice_point", DictValue::arrayReal((double*)0, 0)); + + int axis = getConstBlob(layer, value_id, 0).int_val().Get(0); + layerParams.set("axis", toNCHW[axis]); + + int id = dstNet.addLayer(name, "Slice", layerParams); + layer_id[name] = id; + + // one input only + connect(layer_id, dstNet, parsePin(layer.input(1)), id, 0); + } + else + { + printLayerAttr(layer); + CV_Error_(Error::StsError, ("Unknown layer type %s in op %s", type.c_str(), name.c_str())); + } + } +} + +} // namespace + +Ptr cv::dnn::createTensorflowImporter(const String &model) +{ + return Ptr(new TFImporter(model.c_str())); +} + +#else //HAVE_PROTOBUF + +Ptr cv::dnn::createTensorflowImporter(const String&) +{ + CV_Error(cv::Error::StsNotImplemented, "libprotobuf required to import data from TensorFlow models"); + return Ptr(); +} + +#endif //HAVE_PROTOBUF + +Net cv::dnn::readNetFromTensorflow(const String &model) +{ + Ptr importer = createTensorflowImporter(model); + Net net; + if (importer) + importer->populateNet(net); + return net; +} diff --git a/modules/dnn/src/tensorflow/tf_io.cpp b/modules/dnn/src/tensorflow/tf_io.cpp new file mode 100644 index 0000000000..fafe3cfa9f --- /dev/null +++ b/modules/dnn/src/tensorflow/tf_io.cpp @@ -0,0 +1,63 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Implementation of various functions which are related to Tensorflow models reading. +*/ + +#if HAVE_PROTOBUF +#include +#include +#include + +#include + +#include +#include +#include +#include + +#include "graph.pb.h" +#include "tf_io.hpp" +#include "../caffe/glog_emulator.hpp" + +namespace cv { +namespace dnn { + +using std::string; +using std::map; +using namespace tensorflow; +using namespace ::google::protobuf; +using namespace ::google::protobuf::io; + +const int kProtoReadBytesLimit = INT_MAX; // Max size of 2 GB minus 1 byte. + +// TODO: remove Caffe duplicate +bool ReadProtoFromBinaryFileTF(const char* filename, Message* proto) { + std::ifstream fs(filename, std::ifstream::in | std::ifstream::binary); + CHECK(fs.is_open()) << "Can't open \"" << filename << "\""; + ZeroCopyInputStream* raw_input = new IstreamInputStream(&fs); + CodedInputStream* coded_input = new CodedInputStream(raw_input); + coded_input->SetTotalBytesLimit(kProtoReadBytesLimit, 536870912); + + bool success = proto->ParseFromCodedStream(coded_input); + + delete coded_input; + delete raw_input; + fs.close(); + return success; +} + +void ReadTFNetParamsFromBinaryFileOrDie(const char* param_file, + tensorflow::GraphDef* param) { + CHECK(ReadProtoFromBinaryFileTF(param_file, param)) + << "Failed to parse GraphDef file: " << param_file; +} + +} +} +#endif diff --git a/modules/dnn/src/tensorflow/tf_io.hpp b/modules/dnn/src/tensorflow/tf_io.hpp new file mode 100644 index 0000000000..db9612fc3c --- /dev/null +++ b/modules/dnn/src/tensorflow/tf_io.hpp @@ -0,0 +1,29 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Declaration of various functions which are related to Tensorflow models reading. +*/ + +#ifndef __OPENCV_DNN_TF_IO_HPP__ +#define __OPENCV_DNN_TF_IO_HPP__ +#if HAVE_PROTOBUF + +#include "graph.pb.h" + +namespace cv { +namespace dnn { + +// Read parameters from a file into a GraphDef proto message. +void ReadTFNetParamsFromBinaryFileOrDie(const char* param_file, + tensorflow::GraphDef* param); + +} +} + +#endif +#endif diff --git a/modules/dnn/src/tensorflow/types.proto b/modules/dnn/src/tensorflow/types.proto new file mode 100644 index 0000000000..051361bbed --- /dev/null +++ b/modules/dnn/src/tensorflow/types.proto @@ -0,0 +1,60 @@ +syntax = "proto3"; + +package tensorflow; +option cc_enable_arenas = true; +option java_outer_classname = "TypesProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +enum DataType { + // Not a legal value for DataType. Used to indicate a DataType field + // has not been set. + DT_INVALID = 0; + + // Data types that all computation devices are expected to be + // capable to support. + DT_FLOAT = 1; + DT_DOUBLE = 2; + DT_INT32 = 3; + DT_UINT8 = 4; + DT_INT16 = 5; + DT_INT8 = 6; + DT_STRING = 7; + DT_COMPLEX64 = 8; // Single-precision complex + DT_INT64 = 9; + DT_BOOL = 10; + DT_QINT8 = 11; // Quantized int8 + DT_QUINT8 = 12; // Quantized uint8 + DT_QINT32 = 13; // Quantized int32 + DT_BFLOAT16 = 14; // Float32 truncated to 16 bits. Only for cast ops. + DT_QINT16 = 15; // Quantized int16 + DT_QUINT16 = 16; // Quantized uint16 + DT_UINT16 = 17; + DT_COMPLEX128 = 18; // Double-precision complex + DT_HALF = 19; + + // TODO(josh11b): DT_GENERIC_PROTO = ??; + // TODO(jeff,josh11b): DT_UINT64? DT_UINT32? + + // Do not use! These are only for parameters. Every enum above + // should have a corresponding value below (verified by types_test). + DT_FLOAT_REF = 101; + DT_DOUBLE_REF = 102; + DT_INT32_REF = 103; + DT_UINT8_REF = 104; + DT_INT16_REF = 105; + DT_INT8_REF = 106; + DT_STRING_REF = 107; + DT_COMPLEX64_REF = 108; + DT_INT64_REF = 109; + DT_BOOL_REF = 110; + DT_QINT8_REF = 111; + DT_QUINT8_REF = 112; + DT_QINT32_REF = 113; + DT_BFLOAT16_REF = 114; + DT_QINT16_REF = 115; + DT_QUINT16_REF = 116; + DT_UINT16_REF = 117; + DT_COMPLEX128_REF = 118; + DT_HALF_REF = 119; +} diff --git a/modules/dnn/src/tensorflow/versions.proto b/modules/dnn/src/tensorflow/versions.proto new file mode 100644 index 0000000000..7d5e58ae7d --- /dev/null +++ b/modules/dnn/src/tensorflow/versions.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; + +package tensorflow; +option cc_enable_arenas = true; +option java_outer_classname = "VersionsProtos"; +option java_multiple_files = true; +option java_package = "org.tensorflow.framework"; + +// Version information for a piece of serialized data +// +// There are different types of versions for each type of data +// (GraphDef, etc.), but they all have the same common shape +// described here. +// +// Each consumer has "consumer" and "min_producer" versions (specified +// elsewhere). A consumer is allowed to consume this data if +// +// producer >= min_producer +// consumer >= min_consumer +// consumer not in bad_consumers +// +message VersionDef { + // The version of the code that produced this data. + int32 producer = 1; + + // Any consumer below this version is not allowed to consume this data. + int32 min_consumer = 2; + + // Specific consumer versions which are disallowed (e.g. due to bugs). + repeated int32 bad_consumers = 3; +}; diff --git a/modules/dnn/src/torch/COPYRIGHT.txt b/modules/dnn/src/torch/COPYRIGHT.txt new file mode 100644 index 0000000000..bc002b78ab --- /dev/null +++ b/modules/dnn/src/torch/COPYRIGHT.txt @@ -0,0 +1,36 @@ +Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert) +Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu) +Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu) +Copyright (c) 2011-2013 NYU (Clement Farabet) +Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston) +Copyright (c) 2006 Idiap Research Institute (Samy Bengio) +Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz) + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the names of Deepmind Technologies, NYU, NEC Laboratories America + and IDIAP Research Institute nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/modules/dnn/src/torch/THDiskFile.cpp b/modules/dnn/src/torch/THDiskFile.cpp new file mode 100644 index 0000000000..c56b0f4899 --- /dev/null +++ b/modules/dnn/src/torch/THDiskFile.cpp @@ -0,0 +1,798 @@ +#if defined(ENABLE_TORCH_IMPORTER) && ENABLE_TORCH_IMPORTER +#include "THGeneral.h" +#include "THDiskFile.h" +#include "THFilePrivate.h" + +extern "C" +{ + +typedef struct THDiskFile__ +{ + THFile file; + + FILE *handle; + char *name; + int isNativeEncoding; + int longSize; + +} THDiskFile; + +static int THDiskFile_isOpened(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)self; + return (dfself->handle != NULL); +} + +const char *THDiskFile_name(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)self; + return dfself->name; +} + +/* workaround mac osx lion ***insane*** fread bug */ +#ifdef __APPLE__ +static size_t fread__(void *ptr, size_t size, size_t nitems, FILE *stream) +{ + size_t nread = 0; + while(!feof(stream) && !ferror(stream) && (nread < nitems)) + nread += fread((char*)ptr+nread*size, size, THMin(2147483648UL/size, nitems-nread), stream); + return nread; +} +#else +#define fread__ fread +#endif + +#define READ_WRITE_METHODS(TYPE, TYPEC, ASCII_READ_ELEM, ASCII_WRITE_ELEM) \ + static long THDiskFile_read##TYPEC(THFile *self, TYPE *data, long n) \ + { \ + THDiskFile *dfself = (THDiskFile*)(self); \ + long nread = 0L; \ + \ + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); \ + THArgCheck(dfself->file.isReadable, 1, "attempt to read in a write-only file"); \ + \ + if(dfself->file.isBinary) \ + { \ + nread = fread__(data, sizeof(TYPE), n, dfself->handle); \ + if(!dfself->isNativeEncoding && (sizeof(TYPE) > 1) && (nread > 0)) \ + THDiskFile_reverseMemory(data, data, sizeof(TYPE), nread); \ + } \ + else \ + { \ + long i; \ + for(i = 0; i < n; i++) \ + { \ + ASCII_READ_ELEM; /* increment here result and break if wrong */ \ + } \ + if(dfself->file.isAutoSpacing && (n > 0)) \ + { \ + int c = fgetc(dfself->handle); \ + if( (c != '\n') && (c != EOF) ) \ + ungetc(c, dfself->handle); \ + } \ + } \ + \ + if(nread != n) \ + { \ + dfself->file.hasError = 1; /* shouldn't we put hasError to 0 all the time ? */ \ + if(!dfself->file.isQuiet) \ + THError("read error: read %d blocks instead of %d", nread, n); \ + } \ + \ + return nread; \ + } \ + \ + static long THDiskFile_write##TYPEC(THFile *self, TYPE *data, long n) \ + { \ + THDiskFile *dfself = (THDiskFile*)(self); \ + long nwrite = 0L; \ + \ + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); \ + THArgCheck(dfself->file.isWritable, 1, "attempt to write in a read-only file"); \ + \ + if(dfself->file.isBinary) \ + { \ + if(dfself->isNativeEncoding) \ + { \ + nwrite = fwrite(data, sizeof(TYPE), n, dfself->handle); \ + } \ + else \ + { \ + if(sizeof(TYPE) > 1) \ + { \ + char *buffer = (char*)THAlloc(sizeof(TYPE)*n); \ + THDiskFile_reverseMemory(buffer, data, sizeof(TYPE), n); \ + nwrite = fwrite(buffer, sizeof(TYPE), n, dfself->handle); \ + THFree(buffer); \ + } \ + else \ + nwrite = fwrite(data, sizeof(TYPE), n, dfself->handle); \ + } \ + } \ + else \ + { \ + long i; \ + for(i = 0; i < n; i++) \ + { \ + ASCII_WRITE_ELEM; \ + if( dfself->file.isAutoSpacing && (i < n-1) ) \ + fprintf(dfself->handle, " "); \ + } \ + if(dfself->file.isAutoSpacing && (n > 0)) \ + fprintf(dfself->handle, "\n"); \ + } \ + \ + if(nwrite != n) \ + { \ + dfself->file.hasError = 1; \ + if(!dfself->file.isQuiet) \ + THError("write error: wrote %d blocks instead of %d", nwrite, n); \ + } \ + \ + return nwrite; \ +} + +static int THDiskFile_mode(const char *mode, int *isReadable, int *isWritable) +{ + *isReadable = 0; + *isWritable = 0; + if(strlen(mode) == 1) + { + if(*mode == 'r') + { + *isReadable = 1; + return 1; + } + else if(*mode == 'w') + { + *isWritable = 1; + return 1; + } + } + else if(strlen(mode) == 2) + { + if(mode[0] == 'r' && mode[1] == 'w') + { + *isReadable = 1; + *isWritable = 1; + return 1; + } + } + return 0; +} + +static void THDiskFile_synchronize(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + fflush(dfself->handle); +} + +static void THDiskFile_seek(THFile *self, long position) +{ + THDiskFile *dfself = (THDiskFile*)(self); + + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + +#if defined(_WIN64) + THArgCheck(position <= (_int64)INT64_MAX, 2, "position must be smaller than INT64_MAX"); + if(_fseeki64(dfself->handle, (__int64)position, SEEK_SET) < 0) +#elif defined(_WIN32) + THArgCheck(position <= (long)LONG_MAX, 2, "position must be smaller than LONG_MAX"); + if(fseek(dfself->handle, (long)position, SEEK_SET) < 0) +#else + THArgCheck(position <= (long)LLONG_MAX, 2, "position must be smaller than LLONG_MAX"); + if(fseeko(dfself->handle, (off_t)position, SEEK_SET) < 0) +#endif + { + dfself->file.hasError = 1; + if(!dfself->file.isQuiet) + THError("unable to seek at position %d", position); + } +} + +static void THDiskFile_seekEnd(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + +#if defined(_WIN64) + if(_fseeki64(dfself->handle, 0L, SEEK_END) < 0) +#elif defined(_WIN32) + if(fseek(dfself->handle, 0L, SEEK_END) < 0) +#else + if(fseeko(dfself->handle, 0L, SEEK_END) < 0) +#endif + { + dfself->file.hasError = 1; + if(!dfself->file.isQuiet) + THError("unable to seek at end of file"); + } +} + +static long THDiskFile_position(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + +#if defined(_WIN64) + __int64 offset = _ftelli64(dfself->handle); +#elif defined(_WIN32) + long offset = ftell(dfself->handle); +#else + off_t offset = ftello(dfself->handle); +#endif + if (offset > -1) + return (long)offset; + else if(!dfself->file.isQuiet) + THError("unable to obtain disk file offset (maybe a long overflow occurred)"); + + return 0; +} + +static void THDiskFile_close(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + fclose(dfself->handle); + dfself->handle = NULL; +} + +/* Little and Big Endian */ + +static void THDiskFile_reverseMemory(void *dst, const void *src, long blockSize, long numBlocks) +{ + if(blockSize != 1) + { + long halfBlockSize = blockSize/2; + char *charSrc = (char*)src; + char *charDst = (char*)dst; + long b, i; + for(b = 0; b < numBlocks; b++) + { + for(i = 0; i < halfBlockSize; i++) + { + char z = charSrc[i]; + charDst[i] = charSrc[blockSize-1-i]; + charDst[blockSize-1-i] = z; + } + charSrc += blockSize; + charDst += blockSize; + } + } +} + +int THDiskFile_isLittleEndianCPU(void) +{ + int x = 7; + char *ptr = (char *)&x; + + if(ptr[0] == 0) + return 0; + else + return 1; +} + +int THDiskFile_isBigEndianCPU(void) +{ + return(!THDiskFile_isLittleEndianCPU()); +} + +void THDiskFile_nativeEndianEncoding(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + dfself->isNativeEncoding = 1; +} + +void THDiskFile_littleEndianEncoding(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + dfself->isNativeEncoding = THDiskFile_isLittleEndianCPU(); +} + +void THDiskFile_bigEndianEncoding(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + dfself->isNativeEncoding = !THDiskFile_isLittleEndianCPU(); +} + +/* End of Little and Big Endian Stuff */ + +void THDiskFile_longSize(THFile *self, int size) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + THArgCheck(size == 0 || size == 4 || size == 8, 1, "Invalid long size specified"); + dfself->longSize = size; +} + +void THDiskFile_noBuffer(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + if (setvbuf(dfself->handle, NULL, _IONBF, 0)) { + THError("error: cannot disable buffer"); + } +} + +static void THDiskFile_free(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + if(dfself->handle) + fclose(dfself->handle); + THFree(dfself->name); + THFree(dfself); +} + +/* READ_WRITE_METHODS(int, Bool, */ +/* int value = 0; int ret = fscanf(file->handle, "%d", &value); array[i] = (value ? 1 : 0); if(ret <= 0) break; else result++, */ +/* int value = (array[i] ? 1 : 0); nElemWritten = fprintf(file->handle, "%d", value), */ +/* true) */ + +/* Note that we do a trick */ +READ_WRITE_METHODS(unsigned char, Byte, + nread = fread(data, 1, n, dfself->handle); break, + nwrite = fwrite(data, 1, n, dfself->handle); break) + +READ_WRITE_METHODS(char, Char, + nread = fread(data, 1, n, dfself->handle); break, + nwrite = fwrite(data, 1, n, dfself->handle); break) + +READ_WRITE_METHODS(short, Short, + int ret = fscanf(dfself->handle, "%hd", &data[i]); if(ret <= 0) break; else nread++, + int ret = fprintf(dfself->handle, "%hd", data[i]); if(ret <= 0) break; else nwrite++) + +READ_WRITE_METHODS(int, Int, + int ret = fscanf(dfself->handle, "%d\n\r", &data[i]); if(ret <= 0) break; else nread++, + int ret = fprintf(dfself->handle, "%d", data[i]); if(ret <= 0) break; else nwrite++) + +/*READ_WRITE_METHODS(long, Long, + int ret = fscanf(dfself->handle, "%ld", &data[i]); if(ret <= 0) break; else nread++, + int ret = fprintf(dfself->handle, "%ld", data[i]); if(ret <= 0) break; else nwrite++)*/ + +READ_WRITE_METHODS(float, Float, + int ret = fscanf(dfself->handle, "%g", &data[i]); if(ret <= 0) break; else nread++, + int ret = fprintf(dfself->handle, "%.9g", data[i]); if(ret <= 0) break; else nwrite++) + +READ_WRITE_METHODS(double, Double, + int ret = fscanf(dfself->handle, "%lg", &data[i]); if(ret <= 0) break; else nread++, + int ret = fprintf(dfself->handle, "%.17g", data[i]); if(ret <= 0) break; else nwrite++) + + +/* For Long we need to rewrite everything, because of the special management of longSize */ +static long THDiskFile_readLong(THFile *self, int64 *data, long n) +{ + THDiskFile *dfself = (THDiskFile*)(self); + long nread = 0L; + + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + THArgCheck(dfself->file.isReadable, 1, "attempt to read in a write-only file"); + + if(dfself->file.isBinary) + { + if(dfself->longSize == 0 || dfself->longSize == sizeof(int64)) + { + nread = fread__(data, sizeof(int64), n, dfself->handle); + if(!dfself->isNativeEncoding && (sizeof(int64) > 1) && (nread > 0)) + THDiskFile_reverseMemory(data, data, sizeof(int64), nread); + } else if(dfself->longSize == 4) + { + nread = fread__(data, 4, n, dfself->handle); + if(!dfself->isNativeEncoding && (nread > 0)) + THDiskFile_reverseMemory(data, data, 4, nread); + long i; + for(i = nread; i > 0; i--) + data[i-1] = ((int *)data)[i-1]; + } + else /* if(dfself->longSize == 8) */ + { + int big_endian = !THDiskFile_isLittleEndianCPU(); + int32_t *buffer = (int32_t*)THAlloc(8*n); + nread = fread__(buffer, 8, n, dfself->handle); + long i; + for(i = nread; i > 0; i--) + data[i-1] = buffer[2*(i-1) + big_endian]; + THFree(buffer); + if(!dfself->isNativeEncoding && (nread > 0)) + THDiskFile_reverseMemory(data, data, 4, nread); + } + } + else + { + long i; + for(i = 0; i < n; i++) + { + long d; + int ret = fscanf(dfself->handle, "%ld", &d); if(ret <= 0) break; else nread++; + data[i] = d; + } + if(dfself->file.isAutoSpacing && (n > 0)) + { + int c = fgetc(dfself->handle); + if( (c != '\n') && (c != EOF) ) + ungetc(c, dfself->handle); + } + } + + if(nread != n) + { + dfself->file.hasError = 1; /* shouldn't we put hasError to 0 all the time ? */ + if(!dfself->file.isQuiet) + THError("read error: read %d blocks instead of %d", nread, n); + } + + return nread; +} + +static long THDiskFile_writeLong(THFile *self, int64 *data, long n) +{ + THDiskFile *dfself = (THDiskFile*)(self); + long nwrite = 0L; + + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + THArgCheck(dfself->file.isWritable, 1, "attempt to write in a read-only file"); + + if(dfself->file.isBinary) + { + if(dfself->longSize == 0 || dfself->longSize == sizeof(long)) + { + if(dfself->isNativeEncoding) + { + nwrite = fwrite(data, sizeof(long), n, dfself->handle); + } + else + { + char *buffer = (char*)THAlloc(sizeof(long)*n); + THDiskFile_reverseMemory(buffer, data, sizeof(long), n); + nwrite = fwrite(buffer, sizeof(long), n, dfself->handle); + THFree(buffer); + } + } else if(dfself->longSize == 4) + { + int32_t *buffer = (int32_t *)THAlloc(4*n); + long i; + for(i = 0; i < n; i++) + buffer[i] = data[i]; + if(!dfself->isNativeEncoding) + THDiskFile_reverseMemory(buffer, buffer, 4, n); + nwrite = fwrite(buffer, 4, n, dfself->handle); + THFree(buffer); + } + else /* if(dfself->longSize == 8) */ + { + int big_endian = !THDiskFile_isLittleEndianCPU(); + int32_t *buffer = (int32_t*)THAlloc(8*n); + long i; + for(i = 0; i < n; i++) + { + buffer[2*i + !big_endian] = 0; + buffer[2*i + big_endian] = data[i]; + } + if(!dfself->isNativeEncoding) + THDiskFile_reverseMemory(buffer, buffer, 8, n); + nwrite = fwrite(buffer, 8, n, dfself->handle); + THFree(buffer); + } + } + else + { + long i; + for(i = 0; i < n; i++) + { + long res = 0; + int ret = fprintf(dfself->handle, "%ld", res); data[i] = res; if(ret <= 0) break; else nwrite++; + if( dfself->file.isAutoSpacing && (i < n-1) ) + fprintf(dfself->handle, " "); + } + if(dfself->file.isAutoSpacing && (n > 0)) + fprintf(dfself->handle, "\n"); + } + + if(nwrite != n) + { + dfself->file.hasError = 1; + if(!dfself->file.isQuiet) + THError("write error: wrote %d blocks instead of %d", nwrite, n); + } + + return nwrite; +} + +static long THDiskFile_readString(THFile *self, const char *format, char **str_) +{ + THDiskFile *dfself = (THDiskFile*)(self); + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + THArgCheck(dfself->file.isReadable, 1, "attempt to read in a write-only file"); + THArgCheck((strlen(format) >= 2 ? (format[0] == '*') && (format[1] == 'a' || format[1] == 'l') : 0), 2, "format must be '*a' or '*l'"); + +/* note: the string won't survive long, as it is copied into lua */ +/* so 1024 is not that big... */ +#define TBRS_BSZ 1024L + + if(format[1] == 'a') + { + char *p = (char*)THAlloc(TBRS_BSZ); + long total = TBRS_BSZ; + long pos = 0L; + + for (;;) + { + if(total-pos == 0) /* we need more space! */ + { + total += TBRS_BSZ; + p = (char*)THRealloc(p, total); + } + pos += fread(p+pos, 1, total-pos, dfself->handle); + if (pos < total) /* eof? */ + { + if(pos == 0L) + { + THFree(p); + dfself->file.hasError = 1; + if(!dfself->file.isQuiet) + THError("read error: read 0 blocks instead of 1"); + + *str_ = NULL; + return 0; + } + *str_ = p; + return pos; + } + } + } + else + { + char *p = (char*)THAlloc(TBRS_BSZ); + long total = TBRS_BSZ; + long pos = 0L; + long size; + + for (;;) + { + if(total-pos <= 1) /* we can only write '\0' in there! */ + { + total += TBRS_BSZ; + p = (char*)THRealloc(p, total); + } + if (fgets(p+pos, total-pos, dfself->handle) == NULL) /* eof? */ + { + if(pos == 0L) + { + THFree(p); + dfself->file.hasError = 1; + if(!dfself->file.isQuiet) + THError("read error: read 0 blocks instead of 1"); + + *str_ = NULL; + return 0; + } + *str_ = p; + return pos; + } + size = strlen(p+pos); + if (size == 0L || (p+pos)[size-1] != '\n') + { + pos += size; + } + else + { + pos += size-1L; /* do not include `eol' */ + *str_ = p; + return pos; + } + } + } + + *str_ = NULL; + return 0; +} + + +static long THDiskFile_writeString(THFile *self, const char *str, long size) +{ + THDiskFile *dfself = (THDiskFile*)(self); + long nwrite; + + THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); + THArgCheck(dfself->file.isWritable, 1, "attempt to write in a read-only file"); + + nwrite = fwrite(str, 1, size, dfself->handle); + if(nwrite != size) + { + dfself->file.hasError = 1; + if(!dfself->file.isQuiet) + THError("write error: wrote %ld blocks instead of %ld", nwrite, size); + } + + return nwrite; +} + +THFile *THDiskFile_new(const char *name, const char *mode, int isQuiet) +{ + static struct THFileVTable vtable = { + THDiskFile_isOpened, + + THDiskFile_readByte, + THDiskFile_readChar, + THDiskFile_readShort, + THDiskFile_readInt, + THDiskFile_readLong, + THDiskFile_readFloat, + THDiskFile_readDouble, + THDiskFile_readString, + + THDiskFile_writeByte, + THDiskFile_writeChar, + THDiskFile_writeShort, + THDiskFile_writeInt, + THDiskFile_writeLong, + THDiskFile_writeFloat, + THDiskFile_writeDouble, + THDiskFile_writeString, + + THDiskFile_synchronize, + THDiskFile_seek, + THDiskFile_seekEnd, + THDiskFile_position, + THDiskFile_close, + THDiskFile_free + }; + + int isReadable; + int isWritable; + FILE *handle; + THDiskFile *self; + + THArgCheck(THDiskFile_mode(mode, &isReadable, &isWritable), 2, "file mode should be 'r','w' or 'rw'"); + + if( isReadable && isWritable ) + { + handle = fopen(name, "r+b"); + if(!handle) + { + handle = fopen(name, "wb"); + if(handle) + { + fclose(handle); + handle = fopen(name, "r+b"); + } + } + } + else + handle = fopen(name, (isReadable ? "rb" : "wb")); + + if(!handle) + { + if(isQuiet) + return 0; + else + THError("cannot open <%s> in mode %c%c", name, (isReadable ? 'r' : ' '), (isWritable ? 'w' : ' ')); + } + + self = (THDiskFile*)THAlloc(sizeof(THDiskFile)); + + self->handle = handle; + self->name = (char*)THAlloc(strlen(name)+1); + strcpy(self->name, name); + self->isNativeEncoding = 1; + self->longSize = 0; + + self->file.vtable = &vtable; + self->file.isQuiet = isQuiet; + self->file.isReadable = isReadable; + self->file.isWritable = isWritable; + self->file.isBinary = 0; + self->file.isAutoSpacing = 1; + self->file.hasError = 0; + + return (THFile*)self; +} + +/* PipeFile */ + +static int THPipeFile_mode(const char *mode, int *isReadable, int *isWritable) +{ + *isReadable = 0; + *isWritable = 0; + if(strlen(mode) == 1) + { + if(*mode == 'r') + { + *isReadable = 1; + return 1; + } + else if(*mode == 'w') + { + *isWritable = 1; + return 1; + } + } + return 0; +} + +static void THPipeFile_free(THFile *self) +{ + THDiskFile *dfself = (THDiskFile*)(self); + if(dfself->handle) + pclose(dfself->handle); + THFree(dfself->name); + THFree(dfself); +} + +THFile *THPipeFile_new(const char *name, const char *mode, int isQuiet) +{ + static struct THFileVTable vtable = { + THDiskFile_isOpened, + + THDiskFile_readByte, + THDiskFile_readChar, + THDiskFile_readShort, + THDiskFile_readInt, + THDiskFile_readLong, + THDiskFile_readFloat, + THDiskFile_readDouble, + THDiskFile_readString, + + THDiskFile_writeByte, + THDiskFile_writeChar, + THDiskFile_writeShort, + THDiskFile_writeInt, + THDiskFile_writeLong, + THDiskFile_writeFloat, + THDiskFile_writeDouble, + THDiskFile_writeString, + + THDiskFile_synchronize, + THDiskFile_seek, + THDiskFile_seekEnd, + THDiskFile_position, + THDiskFile_close, + THPipeFile_free + }; + + int isReadable; + int isWritable; + FILE *handle; + THDiskFile *self; + + THArgCheck(THPipeFile_mode(mode, &isReadable, &isWritable), 2, "file mode should be 'r','w'"); + +#ifdef _WIN32 + handle = popen(name, (isReadable ? "rb" : "wb")); +#else + handle = popen(name, (isReadable ? "r" : "w")); +#endif + + if(!handle) + { + if(isQuiet) + return 0; + else + THError("cannot open <%s> in mode %c%c", name, (isReadable ? 'r' : ' '), (isWritable ? 'w' : ' ')); + } + + self = (THDiskFile*)THAlloc(sizeof(THDiskFile)); + + self->handle = handle; + self->name = (char*)THAlloc(strlen(name)+1); + strcpy(self->name, name); + self->isNativeEncoding = 1; + self->longSize = 0; + + self->file.vtable = &vtable; + self->file.isQuiet = isQuiet; + self->file.isReadable = isReadable; + self->file.isWritable = isWritable; + self->file.isBinary = 0; + self->file.isAutoSpacing = 1; + self->file.hasError = 0; + + return (THFile*)self; +} + +} +#endif diff --git a/modules/dnn/src/torch/THDiskFile.h b/modules/dnn/src/torch/THDiskFile.h new file mode 100644 index 0000000000..bc5c001c74 --- /dev/null +++ b/modules/dnn/src/torch/THDiskFile.h @@ -0,0 +1,19 @@ +#ifndef TH_DISK_FILE_INC +#define TH_DISK_FILE_INC + +#include "THFile.h" + +TH_API THFile *THDiskFile_new(const char *name, const char *mode, int isQuiet); +TH_API THFile *THPipeFile_new(const char *name, const char *mode, int isQuiet); + +TH_API const char *THDiskFile_name(THFile *self); + +TH_API int THDiskFile_isLittleEndianCPU(void); +TH_API int THDiskFile_isBigEndianCPU(void); +TH_API void THDiskFile_nativeEndianEncoding(THFile *self); +TH_API void THDiskFile_littleEndianEncoding(THFile *self); +TH_API void THDiskFile_bigEndianEncoding(THFile *self); +TH_API void THDiskFile_longSize(THFile *self, int size); +TH_API void THDiskFile_noBuffer(THFile *self); + +#endif diff --git a/modules/dnn/src/torch/THFile.cpp b/modules/dnn/src/torch/THFile.cpp new file mode 100644 index 0000000000..9e055105ce --- /dev/null +++ b/modules/dnn/src/torch/THFile.cpp @@ -0,0 +1,163 @@ +#if defined(ENABLE_TORCH_IMPORTER) && ENABLE_TORCH_IMPORTER +#include "THFile.h" +#include "THFilePrivate.h" +#include +extern "C" +{ + +#define IMPLEMENT_THFILE_RW(TYPEC, TYPE) \ + long THFile_read##TYPEC##Raw(THFile *self, TYPE *data, long n) \ + { \ + return (*self->vtable->read##TYPEC)(self, data, n); \ + } \ + \ + long THFile_write##TYPEC##Raw(THFile *self, TYPE *data, long n) \ + { \ + return (*self->vtable->write##TYPEC)(self, data, n); \ + } + +IMPLEMENT_THFILE_RW(Byte, unsigned char) +IMPLEMENT_THFILE_RW(Char, char) +IMPLEMENT_THFILE_RW(Short, short) +IMPLEMENT_THFILE_RW(Int, int) +IMPLEMENT_THFILE_RW(Long, int64) +IMPLEMENT_THFILE_RW(Float, float) +IMPLEMENT_THFILE_RW(Double, double) + +long THFile_readStringRaw(THFile *self, const char *format, char **str_) +{ + return self->vtable->readString(self, format, str_); +} + +long THFile_writeStringRaw(THFile *self, const char *str, long size) +{ + return self->vtable->writeString(self, str, size); +} + +void THFile_synchronize(THFile *self) +{ + self->vtable->synchronize(self); +} + +void THFile_seek(THFile *self, long position) +{ + self->vtable->seek(self, position); +} + +void THFile_seekEnd(THFile *self) +{ + self->vtable->seekEnd(self); +} + +long THFile_position(THFile *self) +{ + return self->vtable->position(self); +} + +void THFile_close(THFile *self) +{ + self->vtable->close(self); +} + +void THFile_free(THFile *self) +{ + self->vtable->free(self); +} + +int THFile_isOpened(THFile *self) +{ + return self->vtable->isOpened(self); +} + +#define IMPLEMENT_THFILE_FLAGS(FLAG) \ + int THFile_##FLAG(THFile *self) \ + { \ + return self->FLAG; \ + } + +IMPLEMENT_THFILE_FLAGS(isQuiet) +IMPLEMENT_THFILE_FLAGS(isReadable) +IMPLEMENT_THFILE_FLAGS(isWritable) +IMPLEMENT_THFILE_FLAGS(isBinary) +IMPLEMENT_THFILE_FLAGS(isAutoSpacing) +IMPLEMENT_THFILE_FLAGS(hasError) + +void THFile_binary(THFile *self) +{ + self->isBinary = 1; +} + +void THFile_ascii(THFile *self) +{ + self->isBinary = 0; +} + +void THFile_autoSpacing(THFile *self) +{ + self->isAutoSpacing = 1; +} + +void THFile_noAutoSpacing(THFile *self) +{ + self->isAutoSpacing = 0; +} + +void THFile_quiet(THFile *self) +{ + self->isQuiet = 1; +} + +void THFile_pedantic(THFile *self) +{ + self->isQuiet = 0; +} + +void THFile_clearError(THFile *self) +{ + self->hasError = 0; +} + +#define IMPLEMENT_THFILE_SCALAR(TYPEC, TYPE) \ + TYPE THFile_read##TYPEC##Scalar(THFile *self) \ + { \ + TYPE scalar; \ + THFile_read##TYPEC##Raw(self, &scalar, 1); \ + return scalar; \ + } \ + \ + void THFile_write##TYPEC##Scalar(THFile *self, TYPE scalar) \ + { \ + THFile_write##TYPEC##Raw(self, &scalar, 1); \ + } + +IMPLEMENT_THFILE_SCALAR(Byte, unsigned char) +IMPLEMENT_THFILE_SCALAR(Char, char) +IMPLEMENT_THFILE_SCALAR(Short, short) +IMPLEMENT_THFILE_SCALAR(Int, int) +IMPLEMENT_THFILE_SCALAR(Long, int64) +IMPLEMENT_THFILE_SCALAR(Float, float) +IMPLEMENT_THFILE_SCALAR(Double, double) + +/* +#define IMPLEMENT_THFILE_STORAGE(TYPEC, TYPE) \ + long THFile_read##TYPEC(THFile *self, TH##TYPEC##Storage *storage) \ + { \ + return THFile_read##TYPEC##Raw(self, storage->data, storage->size); \ + } \ + \ + long THFile_write##TYPEC(THFile *self, TH##TYPEC##Storage *storage) \ + { \ + return THFile_write##TYPEC##Raw(self, storage->data, storage->size); \ + } + +IMPLEMENT_THFILE_STORAGE(Byte, unsigned char) +IMPLEMENT_THFILE_STORAGE(Char, char) +IMPLEMENT_THFILE_STORAGE(Short, short) +IMPLEMENT_THFILE_STORAGE(Int, int) +IMPLEMENT_THFILE_STORAGE(Long, long) +IMPLEMENT_THFILE_STORAGE(Float, float) +IMPLEMENT_THFILE_STORAGE(Double, double) +*/ + +} +#endif diff --git a/modules/dnn/src/torch/THFile.h b/modules/dnn/src/torch/THFile.h new file mode 100644 index 0000000000..de362150fe --- /dev/null +++ b/modules/dnn/src/torch/THFile.h @@ -0,0 +1,90 @@ +#ifndef TH_FILE_INC +#define TH_FILE_INC + +//#include "THStorage.h" +#if defined(ENABLE_TORCH_IMPORTER) && ENABLE_TORCH_IMPORTER +#include "THGeneral.h" +#include "opencv2/core/hal/interface.h" + +typedef struct THFile__ THFile; + +TH_API int THFile_isOpened(THFile *self); +TH_API int THFile_isQuiet(THFile *self); +TH_API int THFile_isReadable(THFile *self); +TH_API int THFile_isWritable(THFile *self); +TH_API int THFile_isBinary(THFile *self); +TH_API int THFile_isAutoSpacing(THFile *self); +TH_API int THFile_hasError(THFile *self); + +TH_API void THFile_binary(THFile *self); +TH_API void THFile_ascii(THFile *self); +TH_API void THFile_autoSpacing(THFile *self); +TH_API void THFile_noAutoSpacing(THFile *self); +TH_API void THFile_quiet(THFile *self); +TH_API void THFile_pedantic(THFile *self); +TH_API void THFile_clearError(THFile *self); + +/* scalar */ +TH_API unsigned char THFile_readByteScalar(THFile *self); +TH_API char THFile_readCharScalar(THFile *self); +TH_API short THFile_readShortScalar(THFile *self); +TH_API int THFile_readIntScalar(THFile *self); +TH_API int64 THFile_readLongScalar(THFile *self); +TH_API float THFile_readFloatScalar(THFile *self); +TH_API double THFile_readDoubleScalar(THFile *self); + +TH_API void THFile_writeByteScalar(THFile *self, unsigned char scalar); +TH_API void THFile_writeCharScalar(THFile *self, char scalar); +TH_API void THFile_writeShortScalar(THFile *self, short scalar); +TH_API void THFile_writeIntScalar(THFile *self, int scalar); +TH_API void THFile_writeLongScalar(THFile *self, int64 scalar); +TH_API void THFile_writeFloatScalar(THFile *self, float scalar); +TH_API void THFile_writeDoubleScalar(THFile *self, double scalar); + +/* storage */ +/* +TH_API long THFile_readByte(THFile *self, THByteStorage *storage); +TH_API long THFile_readChar(THFile *self, THCharStorage *storage); +TH_API long THFile_readShort(THFile *self, THShortStorage *storage); +TH_API long THFile_readInt(THFile *self, THIntStorage *storage); +TH_API long THFile_readLong(THFile *self, THLongStorage *storage); +TH_API long THFile_readFloat(THFile *self, THFloatStorage *storage); +TH_API long THFile_readDouble(THFile *self, THDoubleStorage *storage); + +TH_API long THFile_writeByte(THFile *self, THByteStorage *storage); +TH_API long THFile_writeChar(THFile *self, THCharStorage *storage); +TH_API long THFile_writeShort(THFile *self, THShortStorage *storage); +TH_API long THFile_writeInt(THFile *self, THIntStorage *storage); +TH_API long THFile_writeLong(THFile *self, THLongStorage *storage); +TH_API long THFile_writeFloat(THFile *self, THFloatStorage *storage); +TH_API long THFile_writeDouble(THFile *self, THDoubleStorage *storage); +*/ + +/* raw */ +TH_API long THFile_readByteRaw(THFile *self, unsigned char *data, long n); +TH_API long THFile_readCharRaw(THFile *self, char *data, long n); +TH_API long THFile_readShortRaw(THFile *self, short *data, long n); +TH_API long THFile_readIntRaw(THFile *self, int *data, long n); +TH_API long THFile_readLongRaw(THFile *self, int64 *data, long n); +TH_API long THFile_readFloatRaw(THFile *self, float *data, long n); +TH_API long THFile_readDoubleRaw(THFile *self, double *data, long n); +TH_API long THFile_readStringRaw(THFile *self, const char *format, char **str_); /* you must deallocate str_ */ + +TH_API long THFile_writeByteRaw(THFile *self, unsigned char *data, long n); +TH_API long THFile_writeCharRaw(THFile *self, char *data, long n); +TH_API long THFile_writeShortRaw(THFile *self, short *data, long n); +TH_API long THFile_writeIntRaw(THFile *self, int *data, long n); +TH_API long THFile_writeLongRaw(THFile *self, int64 *data, long n); +TH_API long THFile_writeFloatRaw(THFile *self, float *data, long n); +TH_API long THFile_writeDoubleRaw(THFile *self, double *data, long n); +TH_API long THFile_writeStringRaw(THFile *self, const char *str, long size); + +TH_API void THFile_synchronize(THFile *self); +TH_API void THFile_seek(THFile *self, long position); +TH_API void THFile_seekEnd(THFile *self); +TH_API long THFile_position(THFile *self); +TH_API void THFile_close(THFile *self); +TH_API void THFile_free(THFile *self); + +#endif //defined(ENABLE_TORCH_IMPORTER) && ENABLE_TORCH_IMPORTER +#endif //TH_FILE_INC diff --git a/modules/dnn/src/torch/THFilePrivate.h b/modules/dnn/src/torch/THFilePrivate.h new file mode 100644 index 0000000000..dbef9f7459 --- /dev/null +++ b/modules/dnn/src/torch/THFilePrivate.h @@ -0,0 +1,43 @@ +struct THFile__ +{ + struct THFileVTable *vtable; + + int isQuiet; + int isReadable; + int isWritable; + int isBinary; + int isAutoSpacing; + int hasError; +}; + +/* virtual table definition */ + +struct THFileVTable +{ + int (*isOpened)(THFile *self); + + long (*readByte)(THFile *self, unsigned char *data, long n); + long (*readChar)(THFile *self, char *data, long n); + long (*readShort)(THFile *self, short *data, long n); + long (*readInt)(THFile *self, int *data, long n); + long (*readLong)(THFile *self, int64 *data, long n); + long (*readFloat)(THFile *self, float *data, long n); + long (*readDouble)(THFile *self, double *data, long n); + long (*readString)(THFile *self, const char *format, char **str_); + + long (*writeByte)(THFile *self, unsigned char *data, long n); + long (*writeChar)(THFile *self, char *data, long n); + long (*writeShort)(THFile *self, short *data, long n); + long (*writeInt)(THFile *self, int *data, long n); + long (*writeLong)(THFile *self, int64 *data, long n); + long (*writeFloat)(THFile *self, float *data, long n); + long (*writeDouble)(THFile *self, double *data, long n); + long (*writeString)(THFile *self, const char *str, long size); + + void (*synchronize)(THFile *self); + void (*seek)(THFile *self, long position); + void (*seekEnd)(THFile *self); + long (*position)(THFile *self); + void (*close)(THFile *self); + void (*free)(THFile *self); +}; diff --git a/modules/dnn/src/torch/THGeneral.cpp b/modules/dnn/src/torch/THGeneral.cpp new file mode 100644 index 0000000000..1bf0b4f897 --- /dev/null +++ b/modules/dnn/src/torch/THGeneral.cpp @@ -0,0 +1,256 @@ +#if defined(ENABLE_TORCH_IMPORTER) && ENABLE_TORCH_IMPORTER +#include + +#if defined(TH_DISABLE_HEAP_TRACKING) +#elif (defined(__unix) || defined(_WIN32)) +#include +#elif defined(__APPLE__) +#include +#endif + +#include "THGeneral.h" + +extern "C" +{ + +#ifndef TH_HAVE_THREAD +#define __thread +#endif + +/* Torch Error Handling */ +static void defaultTorchErrorHandlerFunction(const char *msg, void*) +{ + CV_Error(cv::Error::StsError, cv::String("Torch Error: ") + msg); +} + +static __thread void (*torchErrorHandlerFunction)(const char *msg, void *data) = defaultTorchErrorHandlerFunction; +static __thread void *torchErrorHandlerData; + +void _THError(const char *file, const int line, const char *fmt, ...) +{ + char msg[2048]; + va_list args; + + /* vasprintf not standard */ + /* vsnprintf: how to handle if does not exists? */ + va_start(args, fmt); + int n = vsnprintf(msg, 2048, fmt, args); + va_end(args); + + if(n < 2048) { + snprintf(msg + n, 2048 - n, " at %s:%d", file, line); + } + + (*torchErrorHandlerFunction)(msg, torchErrorHandlerData); +} + +void _THAssertionFailed(const char *file, const int line, const char *exp, const char *fmt, ...) { + char msg[1024]; + va_list args; + va_start(args, fmt); + vsnprintf(msg, 1024, fmt, args); + va_end(args); + _THError(file, line, "Assertion `%s' failed. %s", exp, msg); +} + +void THSetErrorHandler( void (*torchErrorHandlerFunction_)(const char *msg, void *data), void *data ) +{ + if(torchErrorHandlerFunction_) + torchErrorHandlerFunction = torchErrorHandlerFunction_; + else + torchErrorHandlerFunction = defaultTorchErrorHandlerFunction; + torchErrorHandlerData = data; +} + +/* Torch Arg Checking Handling */ +static void defaultTorchArgErrorHandlerFunction(int argNumber, const char *msg, void*) +{ + if(msg) + CV_Error(cv::Error::StsError, cv::format("Torch invalid argument %d: %s", argNumber, msg)); + else + CV_Error(cv::Error::StsError, cv::format("Invalid argument %d", argNumber)); +} + +static __thread void (*torchArgErrorHandlerFunction)(int argNumber, const char *msg, void *data) = defaultTorchArgErrorHandlerFunction; +static __thread void *torchArgErrorHandlerData; + +void _THArgCheck(const char *file, int line, int condition, int argNumber, const char *fmt, ...) +{ + if(!condition) { + char msg[2048]; + va_list args; + + /* vasprintf not standard */ + /* vsnprintf: how to handle if does not exists? */ + va_start(args, fmt); + int n = vsnprintf(msg, 2048, fmt, args); + va_end(args); + + if(n < 2048) { + snprintf(msg + n, 2048 - n, " at %s:%d", file, line); + } + + (*torchArgErrorHandlerFunction)(argNumber, msg, torchArgErrorHandlerData); + } +} + +void THSetArgErrorHandler( void (*torchArgErrorHandlerFunction_)(int argNumber, const char *msg, void *data), void *data ) +{ + if(torchArgErrorHandlerFunction_) + torchArgErrorHandlerFunction = torchArgErrorHandlerFunction_; + else + torchArgErrorHandlerFunction = defaultTorchArgErrorHandlerFunction; + torchArgErrorHandlerData = data; +} + +static __thread void (*torchGCFunction)(void *data) = NULL; +static __thread void *torchGCData; +static __thread long torchHeapSize = 0; +static __thread long torchHeapSizeSoftMax = 300000000; // 300MB, adjusted upward dynamically + +/* Optional hook for integrating with a garbage-collected frontend. + * + * If torch is running with a garbage-collected frontend (e.g. Lua), + * the GC isn't aware of TH-allocated memory so may not know when it + * needs to run. These hooks trigger the GC to run in two cases: + * + * (1) When a memory allocation (malloc, realloc, ...) fails + * (2) When the total TH-allocated memory hits a dynamically-adjusted + * soft maximum. + */ +void THSetGCHandler( void (*torchGCFunction_)(void *data), void *data ) +{ + torchGCFunction = torchGCFunction_; + torchGCData = data; +} + +static long getAllocSize(void *ptr) { +#if defined(TH_DISABLE_HEAP_TRACKING) + return 0; +#elif defined(__unix) + return malloc_usable_size(ptr); +#elif defined(__APPLE__) + return malloc_size(ptr); +#elif defined(_WIN32) + return _msize(ptr); +#else + return 0; +#endif +} + +/* (1) if the torch-allocated heap size exceeds the soft max, run GC + * (2) if post-GC heap size exceeds 80% of the soft max, increase the + * soft max by 40% + */ +static void maybeTriggerGC() { + if(torchGCFunction && torchHeapSize > torchHeapSizeSoftMax) { + torchGCFunction(torchGCData); + if(torchHeapSize > torchHeapSizeSoftMax * 0.8) { + torchHeapSizeSoftMax = torchHeapSizeSoftMax * 1.4; + } + } +} + +// hooks into the TH heap tracking +void THHeapUpdate(long size) { + torchHeapSize += size; + if (size > 0) + maybeTriggerGC(); +} + +static void* THAllocInternal(long size) +{ + void *ptr; + + if (size > 5120) + { +#if (defined(__unix) || defined(__APPLE__)) && (!defined(DISABLE_POSIX_MEMALIGN)) + if (posix_memalign(&ptr, 64, size) != 0) + ptr = NULL; +/* +#elif defined(_WIN32) + ptr = _aligned_malloc(size, 64); +*/ +#else + ptr = malloc(size); +#endif + } + else + { + ptr = malloc(size); + } + + THHeapUpdate(getAllocSize(ptr)); + return ptr; +} + +void* THAlloc(long size) +{ + void *ptr; + + if(size < 0) + THError("$ Torch: invalid memory size -- maybe an overflow?"); + + if(size == 0) + return NULL; + + ptr = THAllocInternal(size); + + if(!ptr && torchGCFunction) { + torchGCFunction(torchGCData); + ptr = THAllocInternal(size); + } + + if(!ptr) + THError("$ Torch: not enough memory: you tried to allocate %dGB. Buy new RAM!", size/1073741824); + + return ptr; +} + +void* THRealloc(void *ptr, long size) +{ + if(!ptr) + return(THAlloc(size)); + + if(size == 0) + { + THFree(ptr); + return NULL; + } + + if(size < 0) + THError("$ Torch: invalid memory size -- maybe an overflow?"); + + THHeapUpdate(-getAllocSize(ptr)); + void *newptr = realloc(ptr, size); + + if(!newptr && torchGCFunction) { + torchGCFunction(torchGCData); + newptr = realloc(ptr, size); + } + THHeapUpdate(getAllocSize(newptr ? newptr : ptr)); + + if(!newptr) + THError("$ Torch: not enough memory: you tried to reallocate %dGB. Buy new RAM!", size/1073741824); + + return newptr; +} + +void THFree(void *ptr) +{ + THHeapUpdate(-getAllocSize(ptr)); + free(ptr); +} + +double THLog1p(const double x) +{ +#if (defined(_MSC_VER) || defined(__MINGW32__)) + volatile double y = 1 + x; + return log(y) - ((y-1)-x)/y ; /* cancels errors with IEEE arithmetic */ +#else + return log1p(x); +#endif +} + +} +#endif diff --git a/modules/dnn/src/torch/THGeneral.h b/modules/dnn/src/torch/THGeneral.h new file mode 100644 index 0000000000..8d33ede382 --- /dev/null +++ b/modules/dnn/src/torch/THGeneral.h @@ -0,0 +1,89 @@ +#ifndef TH_GENERAL_INC +#define TH_GENERAL_INC + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +# define TH_EXTERNC extern "C" +#else +# define TH_EXTERNC extern +#endif + +#define TH_API TH_EXTERNC + +#define THInf DBL_MAX + +//#define TH_INLINE @TH_INLINE@ + +#ifndef __cplusplus +//#define inline @TH_INLINE@ +#endif + +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +TH_API double THLog1p(const double x); +TH_API void _THError(const char *file, const int line, const char *fmt, ...); +TH_API void _THAssertionFailed(const char *file, const int line, const char *exp, const char *fmt, ...); +TH_API void THSetErrorHandler( void (*torchErrorHandlerFunction)(const char *msg, void *data), void *data ); +TH_API void _THArgCheck(const char *file, int line, int condition, int argNumber, const char *fmt, ...); +TH_API void THSetArgErrorHandler( void (*torchArgErrorHandlerFunction)(int argNumber, const char *msg, void *data), void *data ); +TH_API void* THAlloc(long size); +TH_API void* THRealloc(void *ptr, long size); +TH_API void THFree(void *ptr); +TH_API void THSetGCHandler( void (*torchGCHandlerFunction)(void *data), void *data ); +// this hook should only be called by custom allocator functions +TH_API void THHeapUpdate(long size); + +#define THError(...) _THError(__FILE__, __LINE__, __VA_ARGS__) +#define THArgCheck(...) _THArgCheck(__FILE__, __LINE__, __VA_ARGS__) +#define THAssert(exp) \ +do { \ + if (!(exp)) { \ + _THAssertionFailed(__FILE__, __LINE__, #exp, ""); \ + } \ +} while(0) +#define THAssertMsg(exp, ...) \ +do { \ + if (!(exp)) { \ + _THAssertionFailed(__FILE__, __LINE__, #exp, __VA_ARGS__); \ + } \ +} while(0) + +#define TH_CONCAT_STRING_2(x,y) TH_CONCAT_STRING_2_EXPAND(x,y) +#define TH_CONCAT_STRING_2_EXPAND(x,y) #x #y + +#define TH_CONCAT_STRING_3(x,y,z) TH_CONCAT_STRING_3_EXPAND(x,y,z) +#define TH_CONCAT_STRING_3_EXPAND(x,y,z) #x #y #z + +#define TH_CONCAT_STRING_4(x,y,z,w) TH_CONCAT_STRING_4_EXPAND(x,y,z,w) +#define TH_CONCAT_STRING_4_EXPAND(x,y,z,w) #x #y #z #w + +#define TH_CONCAT_2(x,y) TH_CONCAT_2_EXPAND(x,y) +#define TH_CONCAT_2_EXPAND(x,y) x ## y + +#define TH_CONCAT_3(x,y,z) TH_CONCAT_3_EXPAND(x,y,z) +#define TH_CONCAT_3_EXPAND(x,y,z) x ## y ## z + +#define TH_CONCAT_4_EXPAND(x,y,z,w) x ## y ## z ## w +#define TH_CONCAT_4(x,y,z,w) TH_CONCAT_4_EXPAND(x,y,z,w) + +#define THMin(X, Y) ((X) < (Y) ? (X) : (Y)) +#define THMax(X, Y) ((X) > (Y) ? (X) : (Y)) + +#if (defined(_MSC_VER) || defined(__MINGW32__)) +# define log1p(x) THLog1p(x) +#define snprintf _snprintf +#define popen _popen +#define pclose _pclose +#endif + +#endif diff --git a/modules/dnn/src/torch/torch_importer.cpp b/modules/dnn/src/torch/torch_importer.cpp new file mode 100644 index 0000000000..02e936d314 --- /dev/null +++ b/modules/dnn/src/torch/torch_importer.cpp @@ -0,0 +1,1025 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "../precomp.hpp" +#include +#include +#include +#include +#include +#include + +namespace cv { +namespace dnn { +#if defined(ENABLE_TORCH_IMPORTER) && ENABLE_TORCH_IMPORTER +#include "THDiskFile.h" + +//#ifdef NDEBUG +static bool dbgPrint = false; +//#else +//static bool dbgPrint = true; +//#endif + +enum LuaType +{ + TYPE_NIL = 0, + TYPE_NUMBER = 1, + TYPE_STRING = 2, + TYPE_TABLE = 3, + TYPE_TORCH = 4, + TYPE_BOOLEAN = 5, + TYPE_FUNCTION = 6, + TYPE_RECUR_FUNCTION = 8, + LEGACY_TYPE_RECUR_FUNCTION = 7 +}; + +template +static String toString(const T &v) +{ + std::ostringstream ss; + ss << v; + return ss.str(); +} + +static inline bool startsWith(const String &str, const char *substr) +{ + return str.find(substr) == 0; +} + +static inline bool endsWith(const String &str, const char *substr) +{ + return str.rfind(substr) == str.length() - strlen(substr); +} + +struct TorchImporter : public ::cv::dnn::Importer +{ + typedef std::map > TensorsMap; + Net net; + + THFile *file; + std::set readedIndexes; + std::map storages; + std::map tensors; + + struct Module + { + String thName, apiType; + dnn::LayerParams params; + std::vector > modules; + + Module(const String &_thName, const String &_apiType = String()) + : thName(_thName), apiType(_apiType) {} + }; + + Module *rootModule; + Module *curModule; + int moduleCounter; + + TorchImporter(String filename, bool isBinary) + { + rootModule = curModule = NULL; + moduleCounter = 0; + + file = THDiskFile_new(filename.c_str(), "r", 0); + CV_Assert(file && THFile_isOpened(file)); + + if (isBinary) + THFile_binary(file); + else + THFile_ascii(file); + } + + /* Simple readers */ + + inline int readInt() + { + return THFile_readIntScalar(file); + } + + inline long readLong() + { + return THFile_readLongScalar(file); + } + + inline bool readBool() + { + return readInt() != 0; + } + + inline double readDouble() + { + return THFile_readDoubleScalar(file); + } + + inline String readString() + { + int size = THFile_readIntScalar(file); + String str(size, '\0'); + THFile_readCharRaw(file, const_cast(str.c_str()), size); + return str; + } + + inline String readTorchClassName() + { + String version = readString(); + return startsWith(version, "V ") ? readString() : version; + } + + inline void readFunction() + { + readString(); + readObject(); + } + + void readTable(int index = -1) + { + index = (index < 0) ? readInt() : index; + + if (readedIndexes.count(index)) + return; + + readedIndexes.insert(index); + + int size = readInt(); + + for (int i = 0; i < size; i++) + { + readObject(); //key + readObject(); //value + } + } + + /* Special readers */ + + static inline int parseTorchType(const String &str, const char *suffix, const char *prefix = "torch.") + { + if (startsWith(str, prefix) && endsWith(str, suffix)) + { + String typeStr = str.substr(strlen(prefix), str.length() - strlen(prefix) - strlen(suffix)); + + if (typeStr == "Double") + return CV_64F; + else if (typeStr == "Float" || typeStr == "Cuda") + return CV_32F; + else if (typeStr == "Byte") + return CV_8U; + else if (typeStr == "Char") + return CV_8S; + else if (typeStr == "Short") + return CV_16S; + else if (typeStr == "Int") + return CV_32S; + else if (typeStr == "Long") //Carefully! CV_64S type coded as CV_USRTYPE1 + return CV_USRTYPE1; + else + CV_Error(Error::StsNotImplemented, "Unknown type \"" + typeStr + "\" of torch class \"" + str + "\""); + } + + return -1; + } + + static int parseTensorType(const String &className) + { + return parseTorchType(className, "Tensor"); + } + + static int parseStorageType(const String &className) + { + return parseTorchType(className, "Storage"); + } + + void readTorchStorage(int index, int type = -1) + { + long size = readLong(); + Mat storageMat(1, size, (type != CV_USRTYPE1) ? type : CV_64F); //handle LongStorage as CV_64F Mat + + switch (type) + { + case CV_32F: + THFile_readFloatRaw(file, (float*)storageMat.data, size); + break; + case CV_64F: + THFile_readDoubleRaw(file, (double*)storageMat.data, size); + break; + case CV_8S: + case CV_8U: + THFile_readByteRaw(file, (uchar*)storageMat.data, size); + break; + case CV_16S: + case CV_16U: + THFile_readShortRaw(file, (short*)storageMat.data, size); + break; + case CV_32S: + THFile_readIntRaw(file, (int*)storageMat.data, size); + break; + case CV_USRTYPE1: + { + double *buf = storageMat.ptr(); + THFile_readLongRaw(file, (int64*)buf, size); + + for (size_t i = (size_t)size; i-- > 0; ) + buf[i] = ((int64*)buf)[i]; + } + break; + default: + CV_Error(Error::StsInternal, ""); + break; + } + + storages.insert(std::make_pair(index, storageMat)); + } + + void readTorchTable(Dict &scalarParams, TensorsMap &tensorParams) + { + int luaType = readInt(); + int index = readInt(); + + CV_Assert(luaType == TYPE_TABLE && readedIndexes.count(index) == 0); + readedIndexes.insert(index); + + long fpos; + int numPairs = readInt(); + + for (int i = 0; i < numPairs; i++) + { + fpos = THFile_position(file); + int ktype = readInt(); + + if (ktype != TYPE_STRING) //skip non-string fileds + { + THFile_seek(file, fpos); + readObject(); //key + readObject(); //value + continue; + } + + String key = readString(); + if (dbgPrint) + std::cout << i << "th key: " << key << "\n"; + + fpos = THFile_position(file); + int vtype = readInt(); + + if (vtype == TYPE_TORCH) + { + int index = readInt(); + readTorchObject(index); + + if (tensors.count(index)) //tensor was readed + { + tensorParams.insert(std::make_pair(key, std::make_pair(index, tensors[index]))); + } + else if (storages.count(index)) //storage was readed + { + Mat &matStorage = storages[index]; + Mat matCasted; + matStorage.convertTo(matCasted, CV_64F); + + DictValue scalar = DictValue::arrayReal(matCasted.ptr(), matCasted.total()); + scalarParams.set(key, scalar); + } + } + else if (vtype == TYPE_NUMBER) + { + scalarParams.set(key, readDouble()); + } + else if (vtype == TYPE_STRING) + { + scalarParams.set(key, readString()); + } + else if (vtype == TYPE_BOOLEAN) + { + scalarParams.set(key, readBool()); + } + else + { + THFile_seek(file, fpos); + readObject(); + } + } + + //Debug output + if (dbgPrint) + { + std::cout << "scalarParams:\n"; + std::cout << scalarParams; + + std::cout << "#" << tensorParams.size() << " tensorParams:\n"; + std::map >::const_iterator it; + for (it = tensorParams.begin(); it != tensorParams.end(); it++) + std::cout << it->first << ": Tensor " << it->second.second.size << "\n"; + } + } + + void readTorchTensor(int indexTensor, int typeTensor) + { + int ndims = readInt(); + AutoBuffer sizes(ndims); + AutoBuffer steps(ndims); + THFile_readLongRaw(file, sizes, ndims); + THFile_readLongRaw(file, steps, ndims); + long offset = readLong() - 1; + + //read Storage + int typeidx = readInt(); + CV_Assert(typeidx == TYPE_TORCH || (typeidx == TYPE_NIL && ndims == 0)); + + if (typeidx == TYPE_NIL) + { + tensors.insert(std::make_pair(indexTensor, Mat())); + return; + } + + int indexStorage = readInt(); + if (readedIndexes.count(indexStorage) == 0) + { + String className = readTorchClassName(); + int typeStorage = parseStorageType(className); + CV_Assert(typeStorage >= 0 && typeTensor == typeStorage); + readTorchStorage(indexStorage, typeStorage); + typeTensor = storages[indexStorage].type(); + readedIndexes.insert(indexStorage); + } + + //small check + size_t requireElems = (size_t)offset + (size_t)steps[0] * (size_t)sizes[0]; + size_t storageElems = storages[indexStorage].total(); + if (requireElems > storageElems) + CV_Error(Error::StsBadSize, "Storage has insufficent number of elemements for requested Tensor"); + + //convert sizes + AutoBuffer isizes(ndims); + AutoBuffer ssteps(ndims); + for (int i = ndims - 1; i >= 0; i--) + { + isizes[i] = (int)sizes[i]; + ssteps[i] = (size_t)steps[i] * CV_ELEM_SIZE(typeTensor); + } + + //allocate Blob + Mat srcMat(ndims, (int*)isizes, typeTensor , storages[indexStorage].ptr() + offset*CV_ELEM_SIZE(typeTensor), (size_t*)ssteps); + int dstType = CV_32F; + + Mat blob; + srcMat.convertTo(blob, dstType); + + tensors.insert(std::make_pair(indexTensor, blob)); + } + + static bool isNNClass(const String &className, String &nnName) + { + const char *prefixes[] = {"nn.", "cunn.", "cudnn.", "fbcunn.", NULL}; + + for (int i = 0; prefixes[i]; i++) + { + if (startsWith(className, prefixes[i])) + { + nnName = className.substr(strlen(prefixes[i])); + return true; + } + } + + return false; + } + + static void convertTorchKernelsParams(const Dict &torchParams, cv::dnn::LayerParams &layerParams) + { + layerParams.set("kernel_h", torchParams.get("kH")); + layerParams.set("kernel_w", torchParams.get("kW")); + layerParams.set("stride_h", torchParams.get("dH")); + layerParams.set("stride_w", torchParams.get("dW")); + layerParams.set("pad_h", torchParams.get("padH", 0)); + layerParams.set("pad_w", torchParams.get("padW", 0)); + } + + void readTorchObject(int index) + { + if(readedIndexes.count(index)) + return; + + String className = readTorchClassName(); + String nnName; + + if (dbgPrint) + std::cout << "Class: " << className << std::endl; + + int type; + if ( (type = parseTensorType(className)) >= 0 ) //is Tensor + { + readTorchTensor(index, type); + } + else if ( (type = parseStorageType(className)) >= 0 ) //is Storage + { + readTorchStorage(index, type); + } + else if (isNNClass(className, nnName)) + { + Dict scalarParams; + TensorsMap tensorParams; + + cv::Ptr newModule(new Module(nnName)); + cv::dnn::LayerParams &layerParams = newModule->params; + + layerParams.set("torch_index", index); + + if (nnName == "Sequential" || nnName == "Parallel" || + nnName == "Concat" || nnName == "ConcatTable" || nnName == "JoinTable") + { + Module *parentModule = curModule; + curModule->modules.push_back(newModule); + curModule = newModule; + readTorchTable(scalarParams, tensorParams); + curModule = parentModule; + + if (nnName == "Parallel") + { + layerParams.set("inputDimension", scalarParams.get("inputDimension")); + layerParams.set("outputDimension", scalarParams.get("outputDimension")); + } + if (nnName == "Concat") + { + layerParams.set("dimension", scalarParams.get("dimension")); + } + if (nnName == "JoinTable") + { + layerParams.set("dimension", scalarParams.get("dimension")); + } + } + else if (nnName == "SpatialConvolution") + { + newModule->apiType = "Convolution"; + readTorchTable(scalarParams, tensorParams); + + CV_Assert(tensorParams.count("weight")); + layerParams.blobs.push_back(tensorParams["weight"].second); + + bool bias = tensorParams.count("bias") != 0; + layerParams.set("bias_term", bias); + if (bias) + layerParams.blobs.push_back(tensorParams["bias"].second); + + layerParams.set("num_output", scalarParams.get("nOutputPlane")); + convertTorchKernelsParams(scalarParams, layerParams); + + curModule->modules.push_back(newModule); + } + else if (nnName == "SpatialMaxPooling" || nnName == "SpatialAveragePooling") + { + newModule->apiType = "Pooling"; + readTorchTable(scalarParams, tensorParams); + + if (nnName == "SpatialMaxPooling") { + layerParams.set("pool", "MAX"); + layerParams.set("indices_blob_id", tensorParams["indices"].first); + } + if (nnName == "SpatialAveragePooling") + layerParams.set("pool", "AVE"); + convertTorchKernelsParams(scalarParams, layerParams); + + curModule->modules.push_back(newModule); + } + else if (nnName == "Linear") + { + newModule->apiType = "InnerProduct"; + readTorchTable(scalarParams, tensorParams); + + CV_Assert(tensorParams.count("weight")); + Mat weightBlob = tensorParams["weight"].second; + layerParams.blobs.push_back(weightBlob); + + bool bias = tensorParams.count("bias") != 0; + if (bias) + layerParams.blobs.push_back(tensorParams["bias"].second); + layerParams.set("bias_term", bias); + + layerParams.set("num_output", weightBlob.size[0]); + curModule->modules.push_back(newModule); + } + else if (nnName == "Reshape") + { + newModule->apiType = "Reshape"; + + readTorchTable(scalarParams, tensorParams); + CV_Assert(scalarParams.has("size")); + + DictValue dimParam = scalarParams.get("size"); + layerParams.set("dim", dimParam); + + if (scalarParams.has("batchMode") && scalarParams.get("batchMode")) + layerParams.set("axis", 1); + + curModule->modules.push_back(newModule); + } + else if (nnName == "ReLU") + { + curModule->modules.push_back(cv::Ptr(new Module(nnName, "ReLU"))); + readObject(); + } + else if (nnName == "Tanh") + { + curModule->modules.push_back(cv::Ptr(new Module(nnName, "TanH"))); + readObject(); + } + else if (nnName == "Sigmoid") + { + curModule->modules.push_back(cv::Ptr(new Module(nnName, "Sigmoid"))); + readObject(); + } + else if (nnName == "SpatialBatchNormalization") + { + newModule->apiType = "BatchNorm"; + readTorchTable(scalarParams, tensorParams); + + CV_Assert(tensorParams.count("running_var") && + tensorParams.count("running_mean")); + layerParams.blobs.push_back(tensorParams["running_mean"].second); + layerParams.blobs.push_back(tensorParams["running_var"].second); + + CV_Assert(scalarParams.has("eps")); + float eps = float(scalarParams.get("eps")); + layerParams.set("eps", eps); + + if (tensorParams.count("weight")) + { + layerParams.set("has_weight", true); + layerParams.blobs.push_back(tensorParams["weight"].second); + } + + if (tensorParams.count("bias")) + { + layerParams.set("has_bias", true); + layerParams.blobs.push_back(tensorParams["bias"].second); + } + + curModule->modules.push_back(newModule); + } + else if (nnName == "PReLU") + { + readTorchTable(scalarParams, tensorParams); + + CV_Assert(tensorParams.count("weight")); + + size_t outputChannels = static_cast(scalarParams.get("nOutputPlane")); + if (outputChannels) { + + CV_Assert(tensorParams["weight"].second.total() == outputChannels); + layerParams.blobs.push_back(tensorParams["weight"].second); + + newModule->apiType = "ChannelsPReLU"; + } + else { + CV_Assert(tensorParams["weight"].second.total() == 1); + float negative_slope = *tensorParams["weight"].second.ptr(); + layerParams.set("negative_slope", negative_slope); + + newModule->apiType = "ReLU"; + } + + curModule->modules.push_back(newModule); + } + else if (nnName == "SpatialDropout") + { + readTorchTable(scalarParams, tensorParams); + CV_Assert(scalarParams.has("p")); + + float scale = 1 - scalarParams.get("p"); + + CV_Assert(scale > 0); + + newModule->apiType = "Power"; + layerParams.set("scale", scale); + curModule->modules.push_back(newModule); + } + else if (nnName == "Identity") + { + readTorchTable(scalarParams, tensorParams); + newModule->apiType = "Identity"; + curModule->modules.push_back(newModule); + } + else if (nnName == "Padding") + { + readTorchTable(scalarParams, tensorParams); + newModule->apiType = "Padding"; + + CV_Assert(scalarParams.has("pad") && + scalarParams.has("dim")); + + layerParams.set("padding_dim", + static_cast(scalarParams.get("dim") - 1)); + layerParams.set("padding", static_cast(scalarParams.get("pad"))); + + if (scalarParams.has("nInputDim")) + layerParams.set("input_dims", + static_cast(scalarParams.get("nInputDim"))); + + if (scalarParams.has("value")) + layerParams.set("value", scalarParams.get("value")); + + if (scalarParams.has("index")) + layerParams.set("index", + static_cast(scalarParams.get("index") - 1)); + + curModule->modules.push_back(newModule); + } + else if (nnName == "CAddTable") + { + curModule->modules.push_back(newModule); + readObject(); + } + else if (nnName == "SpatialDilatedConvolution") + { + readTorchTable(scalarParams, tensorParams); + newModule->apiType = "Convolution"; + CV_Assert(scalarParams.has("padW") && + scalarParams.has("padH")&& + scalarParams.has("dW")&& + scalarParams.has("dH")&& + scalarParams.has("dilationW")&& + scalarParams.has("dilationH")&& + scalarParams.has("kW")&& + scalarParams.has("kH")&& + scalarParams.has("nOutputPlane")); + + layerParams.set("kernel_w", static_cast(scalarParams.get("kW"))); + layerParams.set("kernel_h", static_cast(scalarParams.get("kH"))); + layerParams.set("pad_w", static_cast(scalarParams.get("padW"))); + layerParams.set("pad_h", static_cast(scalarParams.get("padH"))); + layerParams.set("stride_w", static_cast(scalarParams.get("dW"))); + layerParams.set("stride_h", static_cast(scalarParams.get("dH"))); + layerParams.set("dilation_w", static_cast(scalarParams.get("dilationW"))); + layerParams.set("dilation_h", static_cast(scalarParams.get("dilationH"))); + layerParams.set("num_output", static_cast(scalarParams.get("nOutputPlane"))); + + layerParams.blobs.push_back(tensorParams["weight"].second); + + bool bias = tensorParams.count("bias"); + layerParams.set("bias_term", bias); + if (bias) + layerParams.blobs.push_back(tensorParams["bias"].second); + + curModule->modules.push_back(newModule); + } + else if (nnName == "SpatialFullConvolution") + { + readTorchTable(scalarParams, tensorParams); + newModule->apiType = "Deconvolution"; + CV_Assert(scalarParams.has("padW") && + scalarParams.has("padH")&& + scalarParams.has("dW")&& + scalarParams.has("dH")&& + scalarParams.has("adjW")&& + scalarParams.has("adjH")&& + scalarParams.has("kW")&& + scalarParams.has("kH")&& + scalarParams.has("nOutputPlane")); + + layerParams.set("kernel_w", static_cast(scalarParams.get("kW"))); + layerParams.set("kernel_h", static_cast(scalarParams.get("kH"))); + layerParams.set("pad_w", static_cast(scalarParams.get("padW"))); + layerParams.set("pad_h", static_cast(scalarParams.get("padH"))); + layerParams.set("stride_w", static_cast(scalarParams.get("dW"))); + layerParams.set("stride_h", static_cast(scalarParams.get("dH"))); + layerParams.set("adj_w", static_cast(scalarParams.get("adjW"))); + layerParams.set("adj_h", static_cast(scalarParams.get("adjH"))); + layerParams.set("num_output", static_cast(scalarParams.get("nOutputPlane"))); + + Mat weights = tensorParams["weight"].second; + CV_Assert(weights.dims == 4); + int reorderedShape[] = { weights.size[1], weights.size[0], weights.size[2], weights.size[3] }; + layerParams.blobs.push_back(weights.reshape(1, 4, reorderedShape)); + + bool bias = tensorParams.count("bias"); + layerParams.set("bias_term", bias); + if (bias) + layerParams.blobs.push_back(tensorParams["bias"].second); + + curModule->modules.push_back(newModule); + } + else if (nnName == "SpatialMaxUnpooling") + { + readTorchTable(scalarParams, tensorParams); + CV_Assert(tensorParams.count("indices")); + + layerParams.set("indices_blob_id", tensorParams["indices"].first); + curModule->modules.push_back(newModule); + } + else if (nnName == "SoftMax") + { + newModule->apiType = "SoftMax"; + curModule->modules.push_back(newModule); + } + else if (nnName == "LogSoftMax") + { + newModule->apiType = "SoftMax"; + layerParams.set("log_softmax", true); + curModule->modules.push_back(newModule); + } + else + { + CV_Error(Error::StsNotImplemented, "Unknown nn class \"" + className + "\""); + } + } + else + { + CV_Error(Error::StsNotImplemented, "Unsupported Torch class \"" + className + "\""); + } + + readedIndexes.insert(index); + } + + void readObject() + { + int typeidx = readInt(); + + if (typeidx == TYPE_TORCH) + { + int index = readInt(); + readTorchObject(index); + readedIndexes.insert(index); + } + else if (typeidx == TYPE_NIL) + return; + else if (typeidx == TYPE_NUMBER) + readDouble(); + else if (typeidx == TYPE_BOOLEAN) + readBool(); + else if (typeidx == TYPE_STRING) + readString(); + else if (typeidx == TYPE_TABLE) + readTable(); + else + CV_Error(Error::StsNotImplemented, "Unsupported Lua type"); + } + + inline String generateLayerName(const String &label = String()) + { + return "l" + toString(++this->moduleCounter) + "_" + label; + } + + int fill(Module *module, std::vector >& addedModules, int prevLayerId = 0, int prevOutNum = 0) + { + if (module == NULL) + return prevLayerId; + + if (module->apiType.length()) + { + int newLayerId = net.addLayer(generateLayerName(module->apiType), module->apiType, module->params); + net.connect(prevLayerId, prevOutNum, newLayerId, 0); + addedModules.push_back(std::make_pair(newLayerId, module)); + return newLayerId; + } + else + { + if (module->thName == "Sequential") + { + for (size_t i = 0; i < module->modules.size(); i++) + { + prevLayerId = fill(module->modules[i], addedModules, prevLayerId, prevOutNum); + prevOutNum = 0; + } + return prevLayerId; + } + else if (module->thName == "Concat") + { + int newId, splitId, mergeId; + LayerParams mergeParams, splitParams; + mergeParams.set("axis", module->params.get("dimension") - 1); + + splitId = net.addLayer(generateLayerName("torchSplit"), "Split", splitParams); + net.connect(prevLayerId, prevOutNum, splitId, 0); + + std::vector branchIds; + for (int i = 0; i < (int)module->modules.size(); i++) + { + newId = fill(module->modules[i], addedModules, splitId, i); + branchIds.push_back(newId); + } + + mergeId = net.addLayer(generateLayerName("torchMerge"), "Concat", mergeParams); + + for (int i = 0; i < branchIds.size(); i++) + { + net.connect(branchIds[i], 0, mergeId, i); + } + + addedModules.push_back(std::make_pair(mergeId, module)); + return mergeId; + } + else if (module->thName == "Parallel") + { + int newId, splitId, mergeId, reshapeId; + + LayerParams splitParams, mergeParams, reshapeParams; + splitParams.set("axis", module->params.get("inputDimension") - 1); + mergeParams.set("axis", module->params.get("outputDimension") - 1); + reshapeParams.set("axis", splitParams.get("axis")); + reshapeParams.set("num_axes", 1); + + splitId = net.addLayer(generateLayerName("torchSplit"), "Slice", splitParams); + reshapeId = net.addLayer(generateLayerName("torchReshape"), "Reshape", reshapeParams); + net.connect(prevLayerId, prevOutNum, splitId, 0); + + std::vector branchIds; + for (int i = 0; i < (int)module->modules.size(); i++) + { + net.connect(splitId, i, reshapeId, i); + newId = fill(module->modules[i], addedModules, reshapeId, i); + branchIds.push_back(newId); + } + + mergeId = net.addLayer(generateLayerName("torchMerge"), "Concat", mergeParams); + + for (int i = 0; i < branchIds.size(); i++) + { + net.connect(branchIds[i], 0, mergeId, i); + } + + addedModules.push_back(std::make_pair(mergeId, module)); + return mergeId; + } + else if (module->thName == "ConcatTable") { + int newId, splitId; + LayerParams splitParams; + + splitId = net.addLayer(generateLayerName("torchSplit"), "Split", splitParams); + net.connect(prevLayerId, prevOutNum, splitId, 0); + + addedModules.push_back(std::make_pair(splitId, module)); + + for (int i = 0; i < (int)module->modules.size(); i++) + { + newId = fill(module->modules[i], addedModules, splitId, i); + } + + return newId; + } + else if (module->thName == "JoinTable") { + std::vector ids = net.getUnconnectedOutLayers(); + + int mergeId; + LayerParams mergeParams; + mergeParams.set("axis", module->params.get("dimension") - 1); + + mergeId = net.addLayer(generateLayerName("torchMerge"), "Concat", mergeParams); + addedModules.push_back(std::make_pair(mergeId, module)); + + for (int i = 0; i < ids.size(); i++) + { + net.connect(ids[i], 0, mergeId, i); + } + + return mergeId; + } + else if (module->thName == "CAddTable") { + String name = generateLayerName("torchCAddTable"); + std::vector ids = net.getUnconnectedOutLayers(); + LayerParams params; + params.set("operation", "sum"); + + + int id = net.addLayer(name, "Eltwise", params); + + for (int i = 0; i < ids.size(); i++) + { + net.connect(ids[i], 0, id, i); + } + + addedModules.push_back(std::make_pair(id, module)); + return id; + } + else if (module->thName == "SpatialMaxUnpooling") { + CV_Assert(module->params.has("indices_blob_id")); + int indicesBlobId = module->params.get("indices_blob_id"); + std::pair poolingLayer; + poolingLayer.first = -1; + + for(int i = 0; i < addedModules.size(); i++) + { + if (addedModules[i].second->apiType == "Pooling" && + addedModules[i].second->params.has("indices_blob_id") && + addedModules[i].second->params.get("indices_blob_id") == indicesBlobId) + { + poolingLayer = addedModules[i]; + break; + } + } + + module->params.set("pool_k_h", poolingLayer.second->params.get("kernel_h")); + module->params.set("pool_k_w", poolingLayer.second->params.get("kernel_w")); + module->params.set("pool_stride_h", poolingLayer.second->params.get("stride_h")); + module->params.set("pool_stride_w", poolingLayer.second->params.get("stride_w")); + module->params.set("pool_pad_h", poolingLayer.second->params.get("pad_h")); + module->params.set("pool_pad_w", poolingLayer.second->params.get("pad_w")); + + String name = generateLayerName("torchMaxUnpooling"); + int id = net.addLayer(name, "MaxUnpool", module->params); + net.connect(prevLayerId, 0, id, 0); + + CV_Assert(poolingLayer.first != -1); + net.connect(poolingLayer.first, 1, id, 1); + + return id; + } + } + + CV_Error(Error::StsInternal, "Unexpected torch container: " + module->thName); + return -1; + } + + void populateNet(Net net_) + { + if (rootModule == NULL) + { + rootModule = new Module("Sequential"); + curModule = rootModule; + + THFile_seek(file, 0); + readObject(); + } + + net = net_; + std::vector > addedModules; + fill(rootModule, addedModules); + } +}; + +Ptr createTorchImporter(const String &filename, bool isBinary) +{ + return Ptr(new TorchImporter(filename, isBinary)); +} + + +Mat readTorchBlob(const String &filename, bool isBinary) +{ + Ptr importer(new TorchImporter(filename, isBinary)); + importer->readObject(); + CV_Assert(importer->tensors.size() == 1); + + return importer->tensors.begin()->second; +} + +#else + +Ptr createTorchImporter(const String&, bool) +{ + CV_Error(Error::StsNotImplemented, "Torch importer is disabled in current build"); + return Ptr(); +} + +Mat readTorchBlob(const String&, bool) +{ + CV_Error(Error::StsNotImplemented, "Torch importer is disabled in current build"); + return Mat(); +} + +#endif //defined(ENABLE_TORCH_IMPORTER) && ENABLE_TORCH_IMPORTER + +Net readNetFromTorch(const String &model, bool isBinary) +{ + Ptr importer = createTorchImporter(model, isBinary); + Net net; + if (importer) + importer->populateNet(net); + return net; +} + +} +} diff --git a/modules/dnn/test/cityscapes_semsegm_test_enet.py b/modules/dnn/test/cityscapes_semsegm_test_enet.py new file mode 100644 index 0000000000..e7e09d4ca4 --- /dev/null +++ b/modules/dnn/test/cityscapes_semsegm_test_enet.py @@ -0,0 +1,142 @@ +import numpy as np +import sys +import os +import fnmatch +import argparse + +# sys.path.append('') +sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') +try: + import cv2 as cv +except ImportError: + raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' + 'uncomment the line before and insert there path to opencv_build_dir/lib dir') +try: + import torch +except ImportError: + raise ImportError('Can\'t find pytorch. Please intall it by following instructions on the official site') + +from torch.utils.serialization import load_lua +from pascal_semsegm_test_fcn import eval_segm_result, get_conf_mat, get_metrics, DatasetImageFetch, SemSegmEvaluation +from imagenet_cls_test_alexnet import Framework, DnnCaffeModel + + +class NormalizePreproc: + def __init__(self): + pass + + @staticmethod + def process(img): + image_data = np.array(img).transpose(2, 0, 1).astype(np.float32) + image_data = np.expand_dims(image_data, 0) + image_data /= 255.0 + return image_data + + +class CityscapesDataFetch(DatasetImageFetch): + img_dir = '' + segm_dir = '' + segm_files = [] + colors = [] + i = 0 + + def __init__(self, img_dir, segm_dir, preproc): + self.img_dir = img_dir + self.segm_dir = segm_dir + self.segm_files = sorted([img for img in self.locate('*_color.png', segm_dir)]) + self.colors = self.get_colors() + self.data_prepoc = preproc + self.i = 0 + + @staticmethod + def get_colors(): + result = [] + colors_list = ( + (0, 0, 0), (128, 64, 128), (244, 35, 232), (70, 70, 70), (102, 102, 156), (190, 153, 153), (153, 153, 153), + (250, 170, 30), (220, 220, 0), (107, 142, 35), (152, 251, 152), (70, 130, 180), (220, 20, 60), (255, 0, 0), + (0, 0, 142), (0, 0, 70), (0, 60, 100), (0, 80, 100), (0, 0, 230), (119, 11, 32)) + + for c in colors_list: + result.append(DatasetImageFetch.pix_to_c(c)) + return result + + def __iter__(self): + return self + + def next(self): + if self.i < len(self.segm_files): + segm_file = self.segm_files[self.i] + segm = cv.imread(segm_file, cv.IMREAD_COLOR)[:, :, ::-1] + segm = cv.resize(segm, (1024, 512), interpolation=cv.INTER_NEAREST) + + img_file = self.rreplace(self.img_dir + segm_file[len(self.segm_dir):], 'gtFine_color', 'leftImg8bit') + assert os.path.exists(img_file) + img = cv.imread(img_file, cv.IMREAD_COLOR)[:, :, ::-1] + img = cv.resize(img, (1024, 512)) + + self.i += 1 + gt = self.color_to_gt(segm, self.colors) + img = self.data_prepoc.process(img) + return img, gt + else: + self.i = 0 + raise StopIteration + + def get_num_classes(self): + return len(self.colors) + + @staticmethod + def locate(pattern, root_path): + for path, dirs, files in os.walk(os.path.abspath(root_path)): + for filename in fnmatch.filter(files, pattern): + yield os.path.join(path, filename) + + @staticmethod + def rreplace(s, old, new, occurrence=1): + li = s.rsplit(old, occurrence) + return new.join(li) + + +class TorchModel(Framework): + net = object + + def __init__(self, model_file): + self.net = load_lua(model_file) + + def get_name(self): + return 'Torch' + + def get_output(self, input_blob): + tensor = torch.FloatTensor(input_blob) + out = self.net.forward(tensor).numpy() + return out + + +class DnnTorchModel(DnnCaffeModel): + net = cv.dnn.Net() + + def __init__(self, model_file): + self.net = cv.dnn.readNetFromTorch(model_file) + + def get_output(self, input_blob): + self.net.setBlob("", input_blob) + self.net.forward() + return self.net.getBlob(self.net.getLayerNames()[-1]) + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--imgs_dir", help="path to Cityscapes validation images dir, imgsfine/leftImg8bit/val") + parser.add_argument("--segm_dir", help="path to Cityscapes dir with segmentation, gtfine/gtFine/val") + parser.add_argument("--model", help="path to torch model, download it here: " + "https://www.dropbox.com/sh/dywzk3gyb12hpe5/AAD5YkUa8XgMpHs2gCRgmCVCa") + parser.add_argument("--log", help="path to logging file") + args = parser.parse_args() + + prep = NormalizePreproc() + df = CityscapesDataFetch(args.imgs_dir, args.segm_dir, prep) + + fw = [TorchModel(args.model), + DnnTorchModel(args.model)] + + segm_eval = SemSegmEvaluation(args.log) + segm_eval.process(fw, df) diff --git a/modules/dnn/test/cnpy.cpp b/modules/dnn/test/cnpy.cpp new file mode 100644 index 0000000000..ee49519f56 --- /dev/null +++ b/modules/dnn/test/cnpy.cpp @@ -0,0 +1,291 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +//Copyright (C) 2011 Carl Rogers +//Released under MIT License +//license available in LICENSE file, or at http://www.opensource.org/licenses/mit-license.php + +#include"cnpy.h" +#include +#include +#include +#include +#include + +char cnpy::BigEndianTest() { + union + { + unsigned char x[2]; + short y; + }; + x[0] = 1; + x[1] = 0; + + return y == 1 ? '<' : '>'; +} + +char cnpy::map_type(const std::type_info& t) +{ + if(t == typeid(float) ) return 'f'; + if(t == typeid(double) ) return 'f'; + if(t == typeid(long double) ) return 'f'; + + if(t == typeid(int) ) return 'i'; + if(t == typeid(char) ) return 'i'; + if(t == typeid(short) ) return 'i'; + if(t == typeid(long) ) return 'i'; + if(t == typeid(long long) ) return 'i'; + + if(t == typeid(unsigned char) ) return 'u'; + if(t == typeid(unsigned short) ) return 'u'; + if(t == typeid(unsigned long) ) return 'u'; + if(t == typeid(unsigned long long) ) return 'u'; + if(t == typeid(unsigned int) ) return 'u'; + + if(t == typeid(bool) ) return 'b'; + + if(t == typeid(std::complex) ) return 'c'; + if(t == typeid(std::complex) ) return 'c'; + if(t == typeid(std::complex) ) return 'c'; + + else return '?'; +} + +template<> std::vector& cnpy::operator+=(std::vector& lhs, const std::string rhs) { + lhs.insert(lhs.end(),rhs.begin(),rhs.end()); + return lhs; +} + +template<> std::vector& cnpy::operator+=(std::vector& lhs, const char* rhs) { + //write in little endian + size_t len = strlen(rhs); + lhs.reserve(len); + for(size_t byte = 0; byte < len; byte++) { + lhs.push_back(rhs[byte]); + } + return lhs; +} + +void cnpy::parse_npy_header(FILE* fp, unsigned int& word_size, unsigned int*& shape, unsigned int& ndims, bool& fortran_order) { + char buffer[256]; + size_t res = fread(buffer,sizeof(char),11,fp); + if(res != 11) + throw std::runtime_error("parse_npy_header: failed fread"); + std::string header = fgets(buffer,256,fp); + cnpy_assert(header[header.size()-1] == '\n'); + + size_t loc1, loc2; + + //fortran order + loc1 = header.find("fortran_order")+16; + fortran_order = (header.substr(loc1,5) == "True" ? true : false); + + //shape + loc1 = header.find("("); + loc2 = header.find(")"); + std::string str_shape = header.substr(loc1+1,loc2-loc1-1); + if(str_shape[str_shape.size()-1] == ',') ndims = 1; + else ndims = (unsigned)std::count(str_shape.begin(),str_shape.end(),',')+1; + shape = new unsigned int[ndims]; + for(unsigned int i = 0;i < ndims;i++) { + loc1 = str_shape.find(","); + shape[i] = atoi(str_shape.substr(0,loc1).c_str()); + str_shape = str_shape.substr(loc1+1); + } + + //endian, word size, data type + //byte order code | stands for not applicable. + //not sure when this applies except for byte array + loc1 = header.find("descr")+9; + bool littleEndian = (header[loc1] == '<' || header[loc1] == '|' ? true : false); + cnpy_assert(littleEndian); + + //char type = header[loc1+1]; + //assert(type == map_type(T)); + + std::string str_ws = header.substr(loc1+2); + loc2 = str_ws.find("'"); + word_size = atoi(str_ws.substr(0,loc2).c_str()); +} + +void cnpy::parse_zip_footer(FILE* fp, unsigned short& nrecs, unsigned int& global_header_size, unsigned int& global_header_offset) +{ + std::vector footer(22); + fseek(fp,-22,SEEK_END); + size_t res = fread(&footer[0],sizeof(char),22,fp); + if(res != 22) + throw std::runtime_error("parse_zip_footer: failed fread"); + + unsigned short disk_no, disk_start, nrecs_on_disk, comment_len; + disk_no = *(unsigned short*) &footer[4]; + disk_start = *(unsigned short*) &footer[6]; + nrecs_on_disk = *(unsigned short*) &footer[8]; + nrecs = *(unsigned short*) &footer[10]; + global_header_size = *(unsigned int*) &footer[12]; + global_header_offset = *(unsigned int*) &footer[16]; + comment_len = *(unsigned short*) &footer[20]; + + cnpy_assert(disk_no == 0); + cnpy_assert(disk_start == 0); + cnpy_assert(nrecs_on_disk == nrecs); + cnpy_assert(comment_len == 0); +} + +cnpy::NpyArray load_the_npy_file(FILE* fp) { + unsigned int* shape; + unsigned int ndims, word_size; + bool fortran_order; + cnpy::parse_npy_header(fp,word_size,shape,ndims,fortran_order); + unsigned long long size = 1; //long long so no overflow when multiplying by word_size + for(unsigned int i = 0;i < ndims;i++) size *= shape[i]; + + cnpy::NpyArray arr; + arr.word_size = word_size; + arr.shape = std::vector(shape,shape+ndims); + delete[] shape; + arr.data = new char[size*word_size]; + arr.fortran_order = fortran_order; + size_t nread = fread(arr.data,word_size,size,fp); + if(nread != size) + throw std::runtime_error("load_the_npy_file: failed fread"); + return arr; +} + +cnpy::npz_t cnpy::npz_load(std::string fname) { + FILE* fp = fopen(fname.c_str(),"rb"); + + if(!fp) printf("npz_load: Error! Unable to open file %s!\n",fname.c_str()); + cnpy_assert(fp); + + cnpy::npz_t arrays; + + while(1) { + std::vector local_header(30); + size_t headerres = fread(&local_header[0],sizeof(char),30,fp); + if(headerres != 30) + throw std::runtime_error("npz_load: failed fread"); + + //if we've reached the global header, stop reading + if(local_header[2] != 0x03 || local_header[3] != 0x04) break; + + //read in the variable name + unsigned short name_len = *(unsigned short*) &local_header[26]; + std::string varname(name_len,' '); + size_t vname_res = fread(&varname[0],sizeof(char),name_len,fp); + if(vname_res != name_len) + throw std::runtime_error("npz_load: failed fread"); + + //erase the lagging .npy + varname.erase(varname.end()-4,varname.end()); + + //read in the extra field + unsigned short extra_field_len = *(unsigned short*) &local_header[28]; + if(extra_field_len > 0) { + std::vector buff(extra_field_len); + size_t efield_res = fread(&buff[0],sizeof(char),extra_field_len,fp); + if(efield_res != extra_field_len) + throw std::runtime_error("npz_load: failed fread"); + } + + arrays[varname] = load_the_npy_file(fp); + } + + fclose(fp); + return arrays; +} + +cnpy::NpyArray cnpy::npz_load(std::string fname, std::string varname) { + FILE* fp = fopen(fname.c_str(),"rb"); + + if(!fp) { + throw std::runtime_error("npz_load: Error! Unable to open file " + fname + "!\n"); + } + + while(1) { + std::vector local_header(30); + size_t header_res = fread(&local_header[0],sizeof(char),30,fp); + if(header_res != 30) + throw std::runtime_error("npz_load: failed fread"); + + //if we've reached the global header, stop reading + if(local_header[2] != 0x03 || local_header[3] != 0x04) break; + + //read in the variable name + unsigned short name_len = *(unsigned short*) &local_header[26]; + std::string vname(name_len,' '); + size_t vname_res = fread(&vname[0],sizeof(char),name_len,fp); + if(vname_res != name_len) + throw std::runtime_error("npz_load: failed fread"); + vname.erase(vname.end()-4,vname.end()); //erase the lagging .npy + + //read in the extra field + unsigned short extra_field_len = *(unsigned short*) &local_header[28]; + fseek(fp,extra_field_len,SEEK_CUR); //skip past the extra field + + if(vname == varname) { + NpyArray array = load_the_npy_file(fp); + fclose(fp); + return array; + } + else { + //skip past the data + unsigned int size = *(unsigned int*) &local_header[22]; + fseek(fp,size,SEEK_CUR); + } + } + + fclose(fp); + throw std::runtime_error("npz_load: Error! Variable name " + varname + " not found in " + fname + "!\n"); +} + +cnpy::NpyArray cnpy::npy_load(std::string fname) { + + FILE* fp = fopen(fname.c_str(), "rb"); + + if(!fp) { + throw std::runtime_error("npy_load: Error! Unable to open file " + fname + "!\n"); + } + + NpyArray arr = load_the_npy_file(fp); + + fclose(fp); + return arr; +} diff --git a/modules/dnn/test/cnpy.h b/modules/dnn/test/cnpy.h new file mode 100644 index 0000000000..37732b04f9 --- /dev/null +++ b/modules/dnn/test/cnpy.h @@ -0,0 +1,294 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +//Copyright (C) 2011 Carl Rogers +//Released under MIT License +//license available in LICENSE file, or at http://www.opensource.org/licenses/mit-license.php + +#ifndef LIBCNPY_H_ +#define LIBCNPY_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if defined(HAVE_ZLIB) && HAVE_ZLIB +#include +#endif + +#ifndef NDEBUG +#define cnpy_assert(expression) assert(expression) +#else +#define cnpy_assert(expression) ((void)(expression)) +#endif + +namespace cnpy { + + struct NpyArray { + char* data; + std::vector shape; + unsigned int word_size; + bool fortran_order; + void destruct() {delete[] data;} + }; + + struct npz_t : public std::map + { + void destruct() + { + npz_t::iterator it = this->begin(); + for(; it != this->end(); ++it) (*it).second.destruct(); + } + }; + + char BigEndianTest(); + char map_type(const std::type_info& t); + template std::vector create_npy_header(const T* data, const unsigned int* shape, const unsigned int ndims); + void parse_npy_header(FILE* fp,unsigned int& word_size, unsigned int*& shape, unsigned int& ndims, bool& fortran_order); + void parse_zip_footer(FILE* fp, unsigned short& nrecs, unsigned int& global_header_size, unsigned int& global_header_offset); + npz_t npz_load(std::string fname); + NpyArray npz_load(std::string fname, std::string varname); + NpyArray npy_load(std::string fname); + + template std::vector& operator+=(std::vector& lhs, const T rhs) { + //write in little endian + for(char byte = 0; (size_t)byte < sizeof(T); byte++) { + char val = *((char*)&rhs+byte); + lhs.push_back(val); + } + return lhs; + } + + template<> std::vector& operator+=(std::vector& lhs, const std::string rhs); + template<> std::vector& operator+=(std::vector& lhs, const char* rhs); + + + template std::string tostring(T i, int = 0, char = ' ') { + std::stringstream s; + s << i; + return s.str(); + } + + template void npy_save(std::string fname, const T* data, const unsigned int* shape, const unsigned int ndims, std::string mode = "w") { + FILE* fp = NULL; + + if(mode == "a") fp = fopen(fname.c_str(),"r+b"); + + if(fp) { + //file exists. we need to append to it. read the header, modify the array size + unsigned int word_size, tmp_dims; + unsigned int* tmp_shape = 0; + bool fortran_order; + parse_npy_header(fp,word_size,tmp_shape,tmp_dims,fortran_order); + cnpy_assert(!fortran_order); + + if(word_size != sizeof(T)) { + std::cout<<"libnpy error: "< header = create_npy_header(data,tmp_shape,ndims); + fwrite(&header[0],sizeof(char),header.size(),fp); + fseek(fp,0,SEEK_END); + + delete[] tmp_shape; + } + else { + fp = fopen(fname.c_str(),"wb"); + std::vector header = create_npy_header(data,shape,ndims); + fwrite(&header[0],sizeof(char),header.size(),fp); + } + + unsigned int nels = 1; + for(unsigned i = 0;i < ndims;i++) nels *= shape[i]; + + fwrite(data,sizeof(T),nels,fp); + fclose(fp); + } + + template void npz_save(std::string zipname, std::string fname, const T* data, const unsigned int* shape, const unsigned int ndims, std::string mode = "w") + { + //first, append a .npy to the fname + fname += ".npy"; + + //now, on with the show + FILE* fp = NULL; + unsigned short nrecs = 0; + unsigned int global_header_offset = 0; + std::vector global_header; + + if(mode == "a") fp = fopen(zipname.c_str(),"r+b"); + + if(fp) { + //zip file exists. we need to add a new npy file to it. + //first read the footer. this gives us the offset and size of the global header + //then read and store the global header. + //below, we will write the the new data at the start of the global header then append the global header and footer below it + unsigned int global_header_size; + parse_zip_footer(fp,nrecs,global_header_size,global_header_offset); + fseek(fp,global_header_offset,SEEK_SET); + global_header.resize(global_header_size); + size_t res = fread(&global_header[0],sizeof(char),global_header_size,fp); + if(res != global_header_size){ + throw std::runtime_error("npz_save: header read error while adding to existing zip"); + } + fseek(fp,global_header_offset,SEEK_SET); + } + else { + fp = fopen(zipname.c_str(),"wb"); + } + + std::vector npy_header = create_npy_header(data,shape,ndims); + + unsigned long nels = 1; + for (unsigned m=0; m local_header; + local_header += "PK"; //first part of sig + local_header += (unsigned short) 0x0403; //second part of sig + local_header += (unsigned short) 20; //min version to extract + local_header += (unsigned short) 0; //general purpose bit flag + local_header += (unsigned short) 0; //compression method + local_header += (unsigned short) 0; //file last mod time + local_header += (unsigned short) 0; //file last mod date + local_header += (unsigned int) crc; //crc + local_header += (unsigned int) nbytes; //compressed size + local_header += (unsigned int) nbytes; //uncompressed size + local_header += (unsigned short) fname.size(); //fname length + local_header += (unsigned short) 0; //extra field length + local_header += fname; + + //build global header + global_header += "PK"; //first part of sig + global_header += (unsigned short) 0x0201; //second part of sig + global_header += (unsigned short) 20; //version made by + global_header.insert(global_header.end(),local_header.begin()+4,local_header.begin()+30); + global_header += (unsigned short) 0; //file comment length + global_header += (unsigned short) 0; //disk number where file starts + global_header += (unsigned short) 0; //internal file attributes + global_header += (unsigned int) 0; //external file attributes + global_header += (unsigned int) global_header_offset; //relative offset of local file header, since it begins where the global header used to begin + global_header += fname; + + //build footer + std::vector footer; + footer += "PK"; //first part of sig + footer += (unsigned short) 0x0605; //second part of sig + footer += (unsigned short) 0; //number of this disk + footer += (unsigned short) 0; //disk where footer starts + footer += (unsigned short) (nrecs+1); //number of records on this disk + footer += (unsigned short) (nrecs+1); //total number of records + footer += (unsigned int) global_header.size(); //nbytes of global headers + footer += (unsigned int) (global_header_offset + nbytes + local_header.size()); //offset of start of global headers, since global header now starts after newly written array + footer += (unsigned short) 0; //zip file comment length + + //write everything + fwrite(&local_header[0],sizeof(char),local_header.size(),fp); + fwrite(&npy_header[0],sizeof(char),npy_header.size(),fp); + fwrite(data,sizeof(T),nels,fp); + fwrite(&global_header[0],sizeof(char),global_header.size(),fp); + fwrite(&footer[0],sizeof(char),footer.size(),fp); + fclose(fp); + } + + template std::vector create_npy_header(const T*, const unsigned int* shape, const unsigned int ndims) { + + std::vector dict; + dict += "{'descr': '"; + dict += BigEndianTest(); + dict += map_type(typeid(T)); + dict += tostring(sizeof(T)); + dict += "', 'fortran_order': False, 'shape': ("; + dict += tostring(shape[0]); + for(unsigned i = 1;i < ndims;i++) { + dict += ", "; + dict += tostring(shape[i]); + } + if(ndims == 1) dict += ","; + dict += "), }"; + //pad with spaces so that preamble+dict is modulo 16 bytes. preamble is 10 bytes. dict needs to end with \n + int remainder = 16 - (10 + dict.size()) % 16; + dict.insert(dict.end(),remainder,' '); + dict.back() = '\n'; + + std::vector header; + header += (unsigned char) 0x93; + header += "NUMPY"; + header += (char) 0x01; //major version of numpy format + header += (char) 0x00; //minor version of numpy format + header += (unsigned short) dict.size(); + header.insert(header.end(),dict.begin(),dict.end()); + + return header; + } + + +} + +#endif diff --git a/modules/dnn/test/imagenet_cls_test_alexnet.py b/modules/dnn/test/imagenet_cls_test_alexnet.py new file mode 100644 index 0000000000..de652040af --- /dev/null +++ b/modules/dnn/test/imagenet_cls_test_alexnet.py @@ -0,0 +1,246 @@ +from abc import ABCMeta, abstractmethod +import numpy as np +import sys +import os +import argparse +import time + +# sys.path.append('') +sys.path.append('/home/arrybn/git/caffe/python') +try: + import caffe +except ImportError: + raise ImportError('Can\'t find caffe. If you\'ve built it from sources without installation, ' + 'uncomment the line before and insert there path to git/caffe/python dir') +# sys.path.append('') +sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') +try: + import cv2 as cv +except ImportError: + raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' + 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + + +class DataFetch(object): + imgs_dir = '' + frame_size = 0 + bgr_to_rgb = False + __metaclass__ = ABCMeta + + @abstractmethod + def preprocess(self, img): + pass + + def get_batch(self, imgs_names): + assert type(imgs_names) is list + batch = np.zeros((len(imgs_names), 3, self.frame_size, self.frame_size)).astype(np.float32) + for i in range(len(imgs_names)): + img_name = imgs_names[i] + img_file = self.imgs_dir + img_name + assert os.path.exists(img_file) + img = cv.imread(img_file, cv.IMREAD_COLOR) + min_dim = min(img.shape[-3], img.shape[-2]) + resize_ratio = self.frame_size / float(min_dim) + img = cv.resize(img, (0, 0), fx=resize_ratio, fy=resize_ratio) + cols = img.shape[1] + rows = img.shape[0] + y1 = (rows - self.frame_size) / 2 + y2 = y1 + self.frame_size + x1 = (cols - self.frame_size) / 2 + x2 = x1 + self.frame_size + img = img[y1:y2, x1:x2] + if self.bgr_to_rgb: + img = img[..., ::-1] + image_data = img[:, :, 0:3].transpose(2, 0, 1) + batch[i] = self.preprocess(image_data) + return batch + + +class MeanBlobFetch(DataFetch): + mean_blob = np.ndarray(()) + + def __init__(self, frame_size, mean_blob_path, imgs_dir): + self.imgs_dir = imgs_dir + self.frame_size = frame_size + blob = caffe.proto.caffe_pb2.BlobProto() + data = open(mean_blob_path, 'rb').read() + blob.ParseFromString(data) + self.mean_blob = np.array(caffe.io.blobproto_to_array(blob)) + start = (self.mean_blob.shape[2] - self.frame_size) / 2 + stop = start + self.frame_size + self.mean_blob = self.mean_blob[:, :, start:stop, start:stop][0] + + def preprocess(self, img): + return img - self.mean_blob + + +class MeanChannelsFetch(MeanBlobFetch): + def __init__(self, frame_size, imgs_dir): + self.imgs_dir = imgs_dir + self.frame_size = frame_size + self.mean_blob = np.ones((3, self.frame_size, self.frame_size)).astype(np.float32) + self.mean_blob[0] *= 104 + self.mean_blob[1] *= 117 + self.mean_blob[2] *= 123 + + +class MeanValueFetch(MeanBlobFetch): + def __init__(self, frame_size, imgs_dir, bgr_to_rgb): + self.imgs_dir = imgs_dir + self.frame_size = frame_size + self.mean_blob = np.ones((3, self.frame_size, self.frame_size)).astype(np.float32) + self.mean_blob *= 117 + self.bgr_to_rgb = bgr_to_rgb + + +def get_correct_answers(img_list, img_classes, net_output_blob): + correct_answers = 0 + for i in range(len(img_list)): + indexes = np.argsort(net_output_blob[i])[-5:] + correct_index = img_classes[img_list[i]] + if correct_index in indexes: + correct_answers += 1 + return correct_answers + + +class Framework(object): + in_blob_name = '' + out_blob_name = '' + + __metaclass__ = ABCMeta + + @abstractmethod + def get_name(self): + pass + + @abstractmethod + def get_output(self, input_blob): + pass + + +class CaffeModel(Framework): + net = caffe.Net + need_reshape = False + + def __init__(self, prototxt, caffemodel, in_blob_name, out_blob_name, need_reshape=False): + caffe.set_mode_cpu() + self.net = caffe.Net(prototxt, caffemodel, caffe.TEST) + self.in_blob_name = in_blob_name + self.out_blob_name = out_blob_name + self.need_reshape = need_reshape + + def get_name(self): + return 'Caffe' + + def get_output(self, input_blob): + if self.need_reshape: + self.net.blobs[self.in_blob_name].reshape(*input_blob.shape) + return self.net.forward_all(**{self.in_blob_name: input_blob})[self.out_blob_name] + + +class DnnCaffeModel(Framework): + net = object + + def __init__(self, prototxt, caffemodel, in_blob_name, out_blob_name): + self.net = cv.dnn.readNetFromCaffe(prototxt, caffemodel) + self.in_blob_name = in_blob_name + self.out_blob_name = out_blob_name + + def get_name(self): + return 'DNN' + + def get_output(self, input_blob): + self.net.setBlob(self.in_blob_name, input_blob) + self.net.forward() + return self.net.getBlob(self.out_blob_name) + + +class ClsAccEvaluation: + log = file + img_classes = {} + batch_size = 0 + + def __init__(self, log_path, img_classes_file, batch_size): + self.log = open(log_path, 'w') + self.img_classes = self.read_classes(img_classes_file) + self.batch_size = batch_size + + @staticmethod + def read_classes(img_classes_file): + result = {} + with open(img_classes_file) as file: + for l in file.readlines(): + result[l.split()[0]] = int(l.split()[1]) + return result + + def process(self, frameworks, data_fetcher): + sorted_imgs_names = sorted(self.img_classes.keys()) + correct_answers = [0] * len(frameworks) + samples_handled = 0 + blobs_l1_diff = [0] * len(frameworks) + blobs_l1_diff_count = [0] * len(frameworks) + blobs_l_inf_diff = [sys.float_info.min] * len(frameworks) + inference_time = [0.0] * len(frameworks) + + for x in xrange(0, len(sorted_imgs_names), self.batch_size): + sublist = sorted_imgs_names[x:x + self.batch_size] + batch = data_fetcher.get_batch(sublist) + + samples_handled += len(sublist) + + frameworks_out = [] + fw_accuracy = [] + for i in range(len(frameworks)): + start = time.time() + out = frameworks[i].get_output(batch) + end = time.time() + correct_answers[i] += get_correct_answers(sublist, self.img_classes, out) + fw_accuracy.append(100 * correct_answers[i] / float(samples_handled)) + frameworks_out.append(out) + inference_time[i] += end - start + print >> self.log, samples_handled, 'Accuracy for', frameworks[i].get_name() + ':', fw_accuracy[i] + print >> self.log, "Inference time, ms ", \ + frameworks[i].get_name(), inference_time[i] / samples_handled * 1000 + + for i in range(1, len(frameworks)): + log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':' + diff = np.abs(frameworks_out[0] - frameworks_out[i]) + l1_diff = np.sum(diff) / diff.size + print >> self.log, samples_handled, "L1 difference", log_str, l1_diff + blobs_l1_diff[i] += l1_diff + blobs_l1_diff_count[i] += 1 + if np.max(diff) > blobs_l_inf_diff[i]: + blobs_l_inf_diff[i] = np.max(diff) + print >> self.log, samples_handled, "L_INF difference", log_str, blobs_l_inf_diff[i] + + self.log.flush() + + for i in range(1, len(blobs_l1_diff)): + log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':' + print >> self.log, 'Final l1 diff', log_str, blobs_l1_diff[i] / blobs_l1_diff_count[i] + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--imgs_dir", help="path to ImageNet validation subset images dir, ILSVRC2012_img_val dir") + parser.add_argument("--img_cls_file", help="path to file with classes ids for images, val.txt file from this " + "archive: http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz") + parser.add_argument("--prototxt", help="path to caffe prototxt, download it here: " + "https://github.com/BVLC/caffe/blob/master/models/bvlc_alexnet/deploy.prototxt") + parser.add_argument("--caffemodel", help="path to caffemodel file, download it here: " + "http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel") + parser.add_argument("--log", help="path to logging file") + parser.add_argument("--mean", help="path to ImageNet mean blob caffe file, imagenet_mean.binaryproto file from" + "this archive: http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz") + parser.add_argument("--batch_size", help="size of images in batch", default=1000) + parser.add_argument("--frame_size", help="size of input image", default=227) + parser.add_argument("--in_blob", help="name for input blob", default='data') + parser.add_argument("--out_blob", help="name for output blob", default='prob') + args = parser.parse_args() + + data_fetcher = MeanBlobFetch(args.frame_size, args.mean, args.imgs_dir) + + frameworks = [CaffeModel(args.prototxt, args.caffemodel, args.in_blob, args.out_blob), + DnnCaffeModel(args.prototxt, args.caffemodel, '', args.out_blob)] + + acc_eval = ClsAccEvaluation(args.log, args.img_cls_file, args.batch_size) + acc_eval.process(frameworks, data_fetcher) diff --git a/modules/dnn/test/imagenet_cls_test_googlenet.py b/modules/dnn/test/imagenet_cls_test_googlenet.py new file mode 100644 index 0000000000..210b740ff9 --- /dev/null +++ b/modules/dnn/test/imagenet_cls_test_googlenet.py @@ -0,0 +1,43 @@ +import numpy as np +import sys +import os +import argparse +from imagenet_cls_test_alexnet import MeanChannelsFetch, CaffeModel, DnnCaffeModel, ClsAccEvaluation +# sys.path.append('') +sys.path.append('/home/arrybn/git/caffe/python') +try: + import caffe +except ImportError: + raise ImportError('Can\'t find caffe. If you\'ve built it from sources without installation, ' + 'uncomment the line before and insert there path to git/caffe/python dir') +# sys.path.append('') +sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') +try: + import cv2 as cv +except ImportError: + raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' + 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--imgs_dir", help="path to ImageNet validation subset images dir, ILSVRC2012_img_val dir") + parser.add_argument("--img_cls_file", help="path to file with classes ids for images, val.txt file from this " + "archive: http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz") + parser.add_argument("--prototxt", help="path to caffe prototxt, download it here: " + "https://github.com/BVLC/caffe/blob/master/models/bvlc_alexnet/deploy.prototxt") + parser.add_argument("--caffemodel", help="path to caffemodel file, download it here: " + "http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel") + parser.add_argument("--log", help="path to logging file") + parser.add_argument("--batch_size", help="size of images in batch", default=500, type=int) + parser.add_argument("--frame_size", help="size of input image", default=224, type=int) + parser.add_argument("--in_blob", help="name for input blob", default='data') + parser.add_argument("--out_blob", help="name for output blob", default='prob') + args = parser.parse_args() + + data_fetcher = MeanChannelsFetch(args.frame_size, args.imgs_dir) + + frameworks = [CaffeModel(args.prototxt, args.caffemodel, args.in_blob, args.out_blob), + DnnCaffeModel(args.prototxt, args.caffemodel, '', args.out_blob)] + + acc_eval = ClsAccEvaluation(args.log, args.img_cls_file, args.batch_size) + acc_eval.process(frameworks, data_fetcher) diff --git a/modules/dnn/test/imagenet_cls_test_inception.py b/modules/dnn/test/imagenet_cls_test_inception.py new file mode 100644 index 0000000000..dc4b1ac846 --- /dev/null +++ b/modules/dnn/test/imagenet_cls_test_inception.py @@ -0,0 +1,79 @@ +import numpy as np +import sys +import os +import argparse +import tensorflow as tf +from tensorflow.python.platform import gfile +from imagenet_cls_test_alexnet import MeanValueFetch, DnnCaffeModel, Framework, ClsAccEvaluation +# sys.path.append('') +sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') +try: + import cv2 as cv +except ImportError: + raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' + 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + +# If you've got an exception "Cannot load libmkl_avx.so or libmkl_def.so" or similar, try to export next variable +# before runnigng the script: +# LD_PRELOAD=/opt/intel/mkl/lib/intel64/libmkl_core.so:/opt/intel/mkl/lib/intel64/libmkl_sequential.so + + +class TensorflowModel(Framework): + sess = tf.Session + output = tf.Graph + + def __init__(self, model_file, in_blob_name, out_blob_name): + self.in_blob_name = in_blob_name + self.sess = tf.Session() + with gfile.FastGFile(model_file, 'rb') as f: + graph_def = tf.GraphDef() + graph_def.ParseFromString(f.read()) + self.sess.graph.as_default() + tf.import_graph_def(graph_def, name='') + self.output = self.sess.graph.get_tensor_by_name(out_blob_name + ":0") + + def get_name(self): + return 'Tensorflow' + + def get_output(self, input_blob): + assert len(input_blob.shape) == 4 + batch_tf = input_blob.transpose(0, 2, 3, 1) + out = self.sess.run(self.output, + {self.in_blob_name+':0': batch_tf}) + out = out[..., 1:1001] + return out + + +class DnnTfInceptionModel(DnnCaffeModel): + net = cv.dnn.Net() + + def __init__(self, model_file, in_blob_name, out_blob_name): + self.net = cv.dnn.readNetFromTensorflow(model_file) + self.in_blob_name = in_blob_name + self.out_blob_name = out_blob_name + + def get_output(self, input_blob): + return super(DnnTfInceptionModel, self).get_output(input_blob)[..., 1:1001] + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--imgs_dir", help="path to ImageNet validation subset images dir, ILSVRC2012_img_val dir") + parser.add_argument("--img_cls_file", help="path to file with classes ids for images, download it here:" + "https://github.com/opencv/opencv_extra/tree/master/testdata/dnn/img_classes_inception.txt") + parser.add_argument("--model", help="path to tensorflow model, download it here:" + "https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip") + parser.add_argument("--log", help="path to logging file") + parser.add_argument("--batch_size", help="size of images in batch", default=1) + parser.add_argument("--frame_size", help="size of input image", default=224) + parser.add_argument("--in_blob", help="name for input blob", default='input') + parser.add_argument("--out_blob", help="name for output blob", default='softmax2') + args = parser.parse_args() + + data_fetcher = MeanValueFetch(args.frame_size, args.imgs_dir, True) + + frameworks = [TensorflowModel(args.model, args.in_blob, args.out_blob), + DnnTfInceptionModel(args.model, '', args.out_blob)] + + acc_eval = ClsAccEvaluation(args.log, args.img_cls_file, args.batch_size) + acc_eval.process(frameworks, data_fetcher) diff --git a/modules/dnn/test/npy_blob.hpp b/modules/dnn/test/npy_blob.hpp new file mode 100644 index 0000000000..89bd24073b --- /dev/null +++ b/modules/dnn/test/npy_blob.hpp @@ -0,0 +1,65 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_DNN_TEST_NPY_BLOB_HPP__ +#define __OPENCV_DNN_TEST_NPY_BLOB_HPP__ +#include "test_precomp.hpp" +#include "cnpy.h" + +namespace cv +{ + +inline Mat blobFromNPY(const String &path) +{ + cnpy::NpyArray npyBlob = cnpy::npy_load(path.c_str()); + Mat blob = Mat((int)npyBlob.shape.size(), (int*)&npyBlob.shape[0], CV_32F, npyBlob.data).clone(); + npyBlob.destruct(); + return blob; +} + +inline void saveBlobToNPY(const Mat &blob, const String &path) +{ + cnpy::npy_save(path.c_str(), blob.ptr(), (unsigned*)&blob.size.p[0], blob.dims); +} + +} + +#endif diff --git a/modules/dnn/test/pascal_semsegm_test_fcn.py b/modules/dnn/test/pascal_semsegm_test_fcn.py new file mode 100644 index 0000000000..2a16c72e53 --- /dev/null +++ b/modules/dnn/test/pascal_semsegm_test_fcn.py @@ -0,0 +1,225 @@ +from abc import ABCMeta, abstractmethod +import numpy as np +import sys +import argparse +import time + +from imagenet_cls_test_alexnet import CaffeModel, DnnCaffeModel +sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') +try: + import cv2 as cv +except ImportError: + raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' + 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + + +def get_metrics(conf_mat): + pix_accuracy = np.trace(conf_mat) / np.sum(conf_mat) + t = np.sum(conf_mat, 1) + num_cl = np.count_nonzero(t) + assert num_cl + mean_accuracy = np.sum(np.nan_to_num(np.divide(np.diagonal(conf_mat), t))) / num_cl + col_sum = np.sum(conf_mat, 0) + mean_iou = np.sum( + np.nan_to_num(np.divide(np.diagonal(conf_mat), (t + col_sum - np.diagonal(conf_mat))))) / num_cl + return pix_accuracy, mean_accuracy, mean_iou + + +def eval_segm_result(net_out): + assert type(net_out) is np.ndarray + assert len(net_out.shape) == 4 + + channels_dim = 1 + y_dim = channels_dim + 1 + x_dim = y_dim + 1 + res = np.zeros(net_out.shape).astype(np.int) + for i in range(net_out.shape[y_dim]): + for j in range(net_out.shape[x_dim]): + max_ch = np.argmax(net_out[..., i, j]) + res[0, max_ch, i, j] = 1 + return res + + +def get_conf_mat(gt, prob): + assert type(gt) is np.ndarray + assert type(prob) is np.ndarray + + conf_mat = np.zeros((gt.shape[0], gt.shape[0])) + for ch_gt in range(conf_mat.shape[0]): + gt_channel = gt[ch_gt, ...] + for ch_pr in range(conf_mat.shape[1]): + prob_channel = prob[ch_pr, ...] + conf_mat[ch_gt][ch_pr] = np.count_nonzero(np.multiply(gt_channel, prob_channel)) + return conf_mat + + +class MeanChannelsPreproc: + def __init__(self): + pass + + @staticmethod + def process(img): + image_data = np.array(img).transpose(2, 0, 1).astype(np.float32) + mean = np.ones(image_data.shape) + mean[0] *= 104 + mean[1] *= 117 + mean[2] *= 123 + image_data -= mean + image_data = np.expand_dims(image_data, 0) + return image_data + + +class DatasetImageFetch(object): + __metaclass__ = ABCMeta + data_prepoc = object + + @abstractmethod + def __iter__(self): + pass + + @abstractmethod + def next(self): + pass + + @staticmethod + def pix_to_c(pix): + return pix[0] * 256 * 256 + pix[1] * 256 + pix[2] + + @staticmethod + def color_to_gt(color_img, colors): + num_classes = len(colors) + gt = np.zeros((num_classes, color_img.shape[0], color_img.shape[1])).astype(np.int) + for img_y in range(color_img.shape[0]): + for img_x in range(color_img.shape[1]): + c = DatasetImageFetch.pix_to_c(color_img[img_y][img_x]) + if c in colors: + cls = colors.index(c) + gt[cls][img_y][img_x] = 1 + return gt + + +class PASCALDataFetch(DatasetImageFetch): + img_dir = '' + segm_dir = '' + names = [] + colors = [] + i = 0 + + def __init__(self, img_dir, segm_dir, names_file, segm_cls_colors_file, preproc): + self.img_dir = img_dir + self.segm_dir = segm_dir + self.colors = self.read_colors(segm_cls_colors_file) + self.data_prepoc = preproc + self.i = 0 + + with open(names_file) as f: + for l in f.readlines(): + self.names.append(l.rstrip()) + + @staticmethod + def read_colors(img_classes_file): + result = [] + with open(img_classes_file) as f: + for l in f.readlines(): + color = np.array(map(int, l.split()[1:])) + result.append(DatasetImageFetch.pix_to_c(color)) + return result + + def __iter__(self): + return self + + def next(self): + if self.i < len(self.names): + name = self.names[self.i] + self.i += 1 + segm_file = self.segm_dir + name + ".png" + img_file = self.img_dir + name + ".jpg" + gt = self.color_to_gt(cv.imread(segm_file, cv.IMREAD_COLOR)[:, :, ::-1], self.colors) + img = self.data_prepoc.process(cv.imread(img_file, cv.IMREAD_COLOR)[:, :, ::-1]) + return img, gt + else: + self.i = 0 + raise StopIteration + + def get_num_classes(self): + return len(self.colors) + + +class SemSegmEvaluation: + log = file + + def __init__(self, log_path,): + self.log = open(log_path, 'w') + + def process(self, frameworks, data_fetcher): + samples_handled = 0 + + conf_mats = [np.zeros((data_fetcher.get_num_classes(), data_fetcher.get_num_classes())) for i in range(len(frameworks))] + blobs_l1_diff = [0] * len(frameworks) + blobs_l1_diff_count = [0] * len(frameworks) + blobs_l_inf_diff = [sys.float_info.min] * len(frameworks) + inference_time = [0.0] * len(frameworks) + + for in_blob, gt in data_fetcher: + frameworks_out = [] + samples_handled += 1 + for i in range(len(frameworks)): + start = time.time() + out = frameworks[i].get_output(in_blob) + end = time.time() + segm = eval_segm_result(out) + conf_mats[i] += get_conf_mat(gt, segm[0]) + frameworks_out.append(out) + inference_time[i] += end - start + + pix_acc, mean_acc, miou = get_metrics(conf_mats[i]) + + name = frameworks[i].get_name() + print >> self.log, samples_handled, 'Pixel accuracy, %s:' % name, 100 * pix_acc + print >> self.log, samples_handled, 'Mean accuracy, %s:' % name, 100 * mean_acc + print >> self.log, samples_handled, 'Mean IOU, %s:' % name, 100 * miou + print >> self.log, "Inference time, ms ", \ + frameworks[i].get_name(), inference_time[i] / samples_handled * 1000 + + for i in range(1, len(frameworks)): + log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':' + diff = np.abs(frameworks_out[0] - frameworks_out[i]) + l1_diff = np.sum(diff) / diff.size + print >> self.log, samples_handled, "L1 difference", log_str, l1_diff + blobs_l1_diff[i] += l1_diff + blobs_l1_diff_count[i] += 1 + if np.max(diff) > blobs_l_inf_diff[i]: + blobs_l_inf_diff[i] = np.max(diff) + print >> self.log, samples_handled, "L_INF difference", log_str, blobs_l_inf_diff[i] + + self.log.flush() + + for i in range(1, len(blobs_l1_diff)): + log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':' + print >> self.log, 'Final l1 diff', log_str, blobs_l1_diff[i] / blobs_l1_diff_count[i] + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--imgs_dir", help="path to PASCAL VOC 2012 images dir, data/VOC2012/JPEGImages") + parser.add_argument("--segm_dir", help="path to PASCAL VOC 2012 segmentation dir, data/VOC2012/SegmentationClass/") + parser.add_argument("--val_names", help="path to file with validation set image names, download it here: " + "https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/data/pascal/seg11valid.txt") + parser.add_argument("--cls_file", help="path to file with colors for classes, download it here: " + "https://github.com/opencv/opencv_contrib/blob/master/modules/dnn/samples/pascal-classes.txt") + parser.add_argument("--prototxt", help="path to caffe prototxt, download it here: " + "https://github.com/opencv/opencv_contrib/blob/master/modules/dnn/samples/fcn8s-heavy-pascal.prototxt") + parser.add_argument("--caffemodel", help="path to caffemodel file, download it here: " + "http://dl.caffe.berkeleyvision.org/fcn8s-heavy-pascal.caffemodel") + parser.add_argument("--log", help="path to logging file") + parser.add_argument("--in_blob", help="name for input blob", default='data') + parser.add_argument("--out_blob", help="name for output blob", default='score') + args = parser.parse_args() + + prep = MeanChannelsPreproc() + df = PASCALDataFetch(args.imgs_dir, args.segm_dir, args.val_names, args.cls_file, prep) + + fw = [CaffeModel(args.prototxt, args.caffemodel, args.in_blob, args.out_blob, True), + DnnCaffeModel(args.prototxt, args.caffemodel, '', args.out_blob)] + + segm_eval = SemSegmEvaluation(args.log) + segm_eval.process(fw, df) diff --git a/modules/dnn/test/test_caffe_importer.cpp b/modules/dnn/test/test_caffe_importer.cpp new file mode 100644 index 0000000000..75c6bb137b --- /dev/null +++ b/modules/dnn/test/test_caffe_importer.cpp @@ -0,0 +1,160 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" +#include "npy_blob.hpp" +#include + +namespace cvtest +{ + +using namespace cv; +using namespace cv::dnn; + +template +static std::string _tf(TString filename) +{ + return (getOpenCVExtraDir() + "/dnn/") + filename; +} + +TEST(Test_Caffe, read_gtsrb) +{ + Net net; + { + Ptr importer = createCaffeImporter(_tf("gtsrb.prototxt"), ""); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } +} + +TEST(Test_Caffe, read_googlenet) +{ + Net net; + { + Ptr importer = createCaffeImporter(_tf("bvlc_googlenet.prototxt"), ""); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } +} + +TEST(Reproducibility_AlexNet, Accuracy) +{ + Net net; + { + const string proto = findDataFile("dnn/bvlc_alexnet.prototxt", false); + const string model = findDataFile("dnn/bvlc_alexnet.caffemodel", false); + Ptr importer = createCaffeImporter(proto, model); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat sample = imread(_tf("grace_hopper_227.png")); + ASSERT_TRUE(!sample.empty()); + + Size inputSize(227, 227); + + if (sample.size() != inputSize) + resize(sample, sample, inputSize); + + net.setInput(blobFromImage(sample), "data"); + Mat out = net.forward("prob"); + Mat ref = blobFromNPY(_tf("caffe_alexnet_prob.npy")); + normAssert(ref, out); +} + +#if !defined(_WIN32) || defined(_WIN64) +TEST(Reproducibility_FCN, Accuracy) +{ + Net net; + { + const string proto = findDataFile("dnn/fcn8s-heavy-pascal.prototxt", false); + const string model = findDataFile("dnn/fcn8s-heavy-pascal.caffemodel", false); + Ptr importer = createCaffeImporter(proto, model); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat sample = imread(_tf("street.png")); + ASSERT_TRUE(!sample.empty()); + + Size inputSize(500, 500); + if (sample.size() != inputSize) + resize(sample, sample, inputSize); + + std::vector layerIds; + std::vector weights, blobs; + net.getMemoryConsumption(shape(1,3,227,227), layerIds, weights, blobs); + + net.setInput(blobFromImage(sample), "data"); + Mat out = net.forward("score"); + Mat ref = blobFromNPY(_tf("caffe_fcn8s_prob.npy")); + normAssert(ref, out); +} +#endif + +TEST(Reproducibility_SSD, Accuracy) +{ + Net net; + { + const string proto = findDataFile("dnn/ssd_vgg16.prototxt", false); + const string model = findDataFile("dnn/VGG_ILSVRC2016_SSD_300x300_iter_440000.caffemodel", false); + Ptr importer = createCaffeImporter(proto, model); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat sample = imread(_tf("street.png")); + ASSERT_TRUE(!sample.empty()); + + if (sample.channels() == 4) + cvtColor(sample, sample, COLOR_BGRA2BGR); + + sample.convertTo(sample, CV_32F); + resize(sample, sample, Size(300, 300)); + + Mat in_blob = blobFromImage(sample); + net.setInput(in_blob, "data"); + Mat out = net.forward("detection_out"); + + Mat ref = blobFromNPY(_tf("ssd_out.npy")); + normAssert(ref, out); +} +} diff --git a/modules/dnn/test/test_common.hpp b/modules/dnn/test/test_common.hpp new file mode 100644 index 0000000000..a436daece1 --- /dev/null +++ b/modules/dnn/test/test_common.hpp @@ -0,0 +1,60 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifndef __OPENCV_TEST_COMMON_HPP__ +#define __OPENCV_TEST_COMMON_HPP__ + +inline const std::string &getOpenCVExtraDir() +{ + return cvtest::TS::ptr()->get_data_path(); +} + +inline void normAssert(cv::InputArray ref, cv::InputArray test, const char *comment = "", + double l1 = 0.00001, double lInf = 0.0001) +{ + double normL1 = cvtest::norm(ref, test, cv::NORM_L1) / ref.getMat().total(); + EXPECT_LE(normL1, l1) << comment; + + double normInf = cvtest::norm(ref, test, cv::NORM_INF); + EXPECT_LE(normInf, lInf) << comment; +} + +#endif diff --git a/modules/dnn/test/test_googlenet.cpp b/modules/dnn/test/test_googlenet.cpp new file mode 100644 index 0000000000..e97281b3d1 --- /dev/null +++ b/modules/dnn/test/test_googlenet.cpp @@ -0,0 +1,107 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" +#include "npy_blob.hpp" +#include +#include + +namespace cvtest +{ + +using namespace cv; +using namespace cv::dnn; + +template +static std::string _tf(TString filename) +{ + return (getOpenCVExtraDir() + "/dnn/") + filename; +} + +static void launchGoogleNetTest() +{ + Net net; + { + const string proto = findDataFile("dnn/bvlc_googlenet.prototxt", false); + const string model = findDataFile("dnn/bvlc_googlenet.caffemodel", false); + Ptr importer = createCaffeImporter(proto, model); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + std::vector inpMats; + inpMats.push_back( imread(_tf("googlenet_0.png")) ); + inpMats.push_back( imread(_tf("googlenet_1.png")) ); + ASSERT_TRUE(!inpMats[0].empty() && !inpMats[1].empty()); + + net.setInput(blobFromImages(inpMats), "data"); + Mat out = net.forward("prob"); + + Mat ref = blobFromNPY(_tf("googlenet_prob.npy")); + normAssert(out, ref); + + std::vector blobsNames; + blobsNames.push_back("conv1/7x7_s2"); + blobsNames.push_back("conv1/relu_7x7"); + blobsNames.push_back("inception_4c/1x1"); + blobsNames.push_back("inception_4c/relu_1x1"); + std::vector outs; + Mat in = blobFromImage(inpMats[0]); + net.setInput(in, "data"); + net.forward(outs, blobsNames); + CV_Assert(outs.size() == blobsNames.size()); + + for (int i = 0; i < blobsNames.size(); i++) + { + std::string filename = blobsNames[i]; + std::replace( filename.begin(), filename.end(), '/', '#'); + Mat ref = blobFromNPY(_tf("googlenet_" + filename + ".npy")); + + normAssert(outs[i], ref, "", 1E-4, 1E-2); + } +} + +TEST(Reproducibility_GoogLeNet, Accuracy) +{ + launchGoogleNetTest(); +} + +} diff --git a/modules/dnn/test/test_halide_layers.cpp b/modules/dnn/test/test_halide_layers.cpp new file mode 100644 index 0000000000..c572a84714 --- /dev/null +++ b/modules/dnn/test/test_halide_layers.cpp @@ -0,0 +1,626 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +// This tests doesn't require any external data. They just compare outputs of +// layers using different computation backends. Input and parameters are random. + +namespace cvtest +{ + +#ifdef HAVE_HALIDE +using namespace cv; +using namespace cv::dnn; +using namespace testing; + +static void test(LayerParams& params, Mat& input) +{ + randu(input, -1.0f, 1.0f); + + Net net; + int lid = net.addLayer(params.name, params.type, params); + net.connect(0, 0, lid, 0); + + net.setInput(input); + Mat outputDefault = net.forward(params.name).clone(); + + net.setPreferableBackend(DNN_BACKEND_HALIDE); + Mat outputHalide = net.forward(params.name).clone(); + normAssert(outputDefault, outputHalide); +} + +//////////////////////////////////////////////////////////////////////////////// +// Convolution +//////////////////////////////////////////////////////////////////////////////// +typedef TestWithParam > Convolution; +TEST_P(Convolution, Accuracy) +{ + int inChannels = get<0>(GetParam())[0]; + int outChannels = get<0>(GetParam())[1]; + int group = get<0>(GetParam())[2]; + Size inSize = get<1>(GetParam()); + Size kernel = get<2>(GetParam()); + Size stride = get<3>(GetParam()); + Size pad = get<4>(GetParam()); + Size dilation = get<5>(GetParam()); + bool hasBias = get<6>(GetParam()); + + Mat weights({outChannels, inChannels / group, kernel.height, kernel.width}, CV_32F); + randu(weights, -1.0f, 1.0f); + + LayerParams lp; + lp.set("kernel_w", kernel.width); + lp.set("kernel_h", kernel.height); + lp.set("pad_w", pad.width); + lp.set("pad_h", pad.height); + lp.set("stride_w", stride.width); + lp.set("stride_h", stride.height); + lp.set("dilation_w", dilation.width); + lp.set("dilation_h", dilation.height); + lp.set("num_output", outChannels); + lp.set("group", group); + lp.set("bias_term", hasBias); + lp.type = "Convolution"; + lp.name = "testLayer"; + lp.blobs.push_back(weights); + if (hasBias) + { + Mat bias({outChannels}, CV_32F); + randu(bias, -1.0f, 1.0f); + lp.blobs.push_back(bias); + } + Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F); + test(lp, input); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Convolution, Combine( +/*in channels, out channels, group*/ + Values(Vec3i(6, 4, 1), Vec3i(6, 9, 1), + Vec3i(6, 4, 2), Vec3i(6, 9, 3)), +/*in size*/ Values(Size(5, 6)), +/*kernel*/ Values(Size(3, 1), Size(1, 3)), +/*stride*/ Values(Size(1, 1), Size(2, 2)), +/*pad*/ Values(Size(1, 0), Size(0, 1)), +/*dilation*/ Values(Size(1, 1), Size(2, 2)), +/*has bias*/ Bool() +)); + +//////////////////////////////////////////////////////////////////////////////// +// Deconvolution +//////////////////////////////////////////////////////////////////////////////// +typedef TestWithParam > Deconvolution; +TEST_P(Deconvolution, Accuracy) +{ + int inChannels = get<0>(GetParam())[0]; + int outChannels = get<0>(GetParam())[1]; + int group = get<0>(GetParam())[2]; + Size inSize = get<1>(GetParam()); + Size kernel = get<2>(GetParam()); + Size pad = get<3>(GetParam()); + Size dilation = get<4>(GetParam()); + Size stride = Size(get<5>(GetParam())[0], get<5>(GetParam())[1]); + Size adjPad = Size(get<5>(GetParam())[2], get<5>(GetParam())[3]); + bool hasBias = get<6>(GetParam()); + + Mat weights({outChannels, inChannels / group, kernel.height, kernel.width}, CV_32F); + randu(weights, -1.0f, 1.0f); + + LayerParams lp; + lp.set("kernel_w", kernel.width); + lp.set("kernel_h", kernel.height); + lp.set("pad_w", pad.width); + lp.set("pad_h", pad.height); + lp.set("stride_w", stride.width); + lp.set("stride_h", stride.height); + lp.set("dilation_w", dilation.width); + lp.set("dilation_h", dilation.height); + lp.set("adj_w", adjPad.width); + lp.set("adj_h", adjPad.height); + lp.set("num_output", outChannels); + lp.set("group", group); + lp.set("bias_term", hasBias); + lp.type = "Deconvolution"; + lp.name = "testLayer"; + lp.blobs.push_back(weights); + if (hasBias) + { + Mat bias({outChannels}, CV_32F); + randu(bias, -1.0f, 1.0f); + lp.blobs.push_back(bias); + } + Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F); + test(lp, input); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Deconvolution, Combine( +/*in channels, out channels, group*/ + Values(Vec3i(6, 4, 1), Vec3i(6, 9, 1)), +/*in size*/ Values(Size(5, 6)), +/*kernel*/ Values(Size(3, 1), Size(1, 3)), +/*pad*/ Values(Size(1, 0), Size(0, 1)), +/*dilation*/ Values(Size(1, 1), Size(2, 2)), +/*stride, adj. pad*/ Values(Vec4i(1,1, 0,0), Vec4i(2,2, 1,0), Vec4i(1,2, 0,1)), +/*has bias*/ Bool() +)); + +//////////////////////////////////////////////////////////////////////////////// +// LRN +//////////////////////////////////////////////////////////////////////////////// +typedef TestWithParam > LRN; +TEST_P(LRN, Accuracy) +{ + int inChannels = get<0>(GetParam())[0]; + Size inSize = Size(get<0>(GetParam())[1], get<0>(GetParam())[2]); + int localSize = get<1>(GetParam()); + float alpha = get<2>(GetParam())[0]; + float beta = get<2>(GetParam())[1]; + float bias = get<2>(GetParam())[2]; + bool normBySize = get<3>(GetParam()); + std::string nrmType = get<4>(GetParam()); + + LayerParams lp; + lp.set("norm_region", nrmType); + lp.set("local_size", localSize); + lp.set("alpha", alpha); + lp.set("beta", beta); + lp.set("bias", bias); + lp.set("norm_by_size", normBySize); + lp.type = "LRN"; + lp.name = "testLayer"; + + Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F); + test(lp, input); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, LRN, Combine( +/*input ch,w,h*/ Values(Vec3i(6, 5, 8), Vec3i(7, 11, 6)), +/*local size*/ Values(3, 5), + Values(Vec3f(0.9f, 1.0f, 1.1f), Vec3f(0.9f, 1.1f, 1.0f), +/*alpha, beta,*/ Vec3f(1.0f, 0.9f, 1.1f), Vec3f(1.0f, 1.1f, 0.9f), +/*bias */ Vec3f(1.1f, 0.9f, 1.0f), Vec3f(1.1f, 1.0f, 0.9f)), +/*norm_by_size*/ Bool(), +/*norm_type*/ Values("ACROSS_CHANNELS", "WITHIN_CHANNEL") +)); + +//////////////////////////////////////////////////////////////////////////////// +// Average pooling +//////////////////////////////////////////////////////////////////////////////// +typedef TestWithParam > AvePooling; +TEST_P(AvePooling, Accuracy) +{ + int inChannels = get<0>(GetParam()); + Size outSize = get<1>(GetParam());; // Input size will be computed from parameters. + Size kernel = get<2>(GetParam()); + Size stride = get<3>(GetParam()); + + const int inWidth = (outSize.width - 1) * stride.width + kernel.width; + const int inHeight = (outSize.height - 1) * stride.height + kernel.height; + + LayerParams lp; + lp.set("pool", "ave"); + lp.set("kernel_w", kernel.width); + lp.set("kernel_h", kernel.height); + lp.set("stride_w", stride.width); + lp.set("stride_h", stride.height); + lp.type = "Pooling"; + lp.name = "testLayer"; + + Mat input({1, inChannels, inHeight, inWidth}, CV_32F); + test(lp, input); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, AvePooling, Combine( +/*in channels*/ Values(3, 4), +/*out size*/ Values(Size(1, 1), Size(2, 2), Size(3, 2), Size(4, 7)), +/*kernel*/ Values(Size(1, 1), Size(2, 2), Size(3, 3), Size(3, 2)), +/*stride*/ Values(Size(1, 1), Size(2, 2), Size(3, 2)) +)); + +//////////////////////////////////////////////////////////////////////////////// +// Maximum pooling +//////////////////////////////////////////////////////////////////////////////// +typedef TestWithParam > MaxPooling; +TEST_P(MaxPooling, Accuracy) +{ + int inChannels = get<0>(GetParam()); + Size inSize = get<1>(GetParam()); + Size kernel = get<2>(GetParam()); + Size stride = get<3>(GetParam()); + Size pad = get<4>(GetParam()); + + LayerParams lp; + lp.set("pool", "max"); + lp.set("kernel_w", kernel.width); + lp.set("kernel_h", kernel.height); + lp.set("stride_w", stride.width); + lp.set("stride_h", stride.height); + lp.set("pad_w", pad.width); + lp.set("pad_h", pad.height); + lp.type = "Pooling"; + lp.name = "testLayer"; + + Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F); + test(lp, input); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, MaxPooling, Combine( +/*in channels*/ Values(3, 4), +/*in size*/ Values(Size(5, 5), Size(7, 6)), +/*kernel*/ Values(Size(2, 2), Size(3, 3), Size(3, 2)), +/*stride*/ Values(Size(1, 1), Size(2, 2), Size(3, 2)), +/*pad*/ Values(Size(0, 0), Size(1, 1), Size(0, 1)) +)); + +//////////////////////////////////////////////////////////////////////////////// +// Fully-connected +//////////////////////////////////////////////////////////////////////////////// +typedef TestWithParam > FullyConnected; +TEST_P(FullyConnected, Accuracy) +{ + int inChannels = get<0>(GetParam()); + Size inSize = get<1>(GetParam()); + int outChannels = get<2>(GetParam()); + bool hasBias = get<3>(GetParam()); + + Mat weights(outChannels, inChannels * inSize.height * inSize.width, CV_32F); + randu(weights, -1.0f, 1.0f); + + Mat bias(1, outChannels, CV_32F); + randu(bias, -1.0f, 1.0f); + + LayerParams lp; + lp.set("num_output", outChannels); + lp.set("bias_term", hasBias); + lp.blobs.push_back(weights); + lp.blobs.push_back(bias); + lp.type = "InnerProduct"; + lp.name = "testLayer"; + + Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F); + test(lp, input); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, FullyConnected, Combine( +/*in channels*/ Values(3, 4), +/*in size*/ Values(Size(5, 4), Size(4, 5), Size(1, 1)), +/*out channels*/ Values(3, 4), +/*has bias*/ Bool() +)); + +//////////////////////////////////////////////////////////////////////////////// +// SoftMax +//////////////////////////////////////////////////////////////////////////////// +typedef TestWithParam > SoftMax; +TEST_P(SoftMax, Accuracy) +{ + int inChannels = get<0>(GetParam()); + LayerParams lp; + lp.type = "SoftMax"; + lp.name = "testLayer"; + + Mat input({1, inChannels, 1, 1}, CV_32F); + test(lp, input); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, SoftMax, Values(3, 4, 5, 1024)); + +////////////////////////////////////////////////////////////////////////////// +// Max pooling - unpooling +////////////////////////////////////////////////////////////////////////////// +TEST(MaxPoolUnpool_Halide, Accuracy) +{ + LayerParams pool; + pool.set("pool", "max"); + pool.set("kernel_w", 2); + pool.set("kernel_h", 2); + pool.set("stride_w", 2); + pool.set("stride_h", 2); + pool.set("pad_w", 0); + pool.set("pad_h", 0); + pool.type = "Pooling"; + pool.name = "testPool"; + + LayerParams unpool; + unpool.set("pool_k_w", 2); + unpool.set("pool_k_h", 2); + unpool.set("pool_stride_w", 2); + unpool.set("pool_stride_h", 2); + unpool.set("pool_pad_w", 0); + unpool.set("pool_pad_h", 0); + unpool.type = "MaxUnpool"; + unpool.name = "testUnpool"; + + Net net; + int poolId = net.addLayer(pool.name, pool.type, pool); + net.connect(0, 0, poolId, 0); + + int unpoolId = net.addLayer(unpool.name, unpool.type, unpool); + net.connect(poolId, 0, unpoolId, 0); + net.connect(poolId, 1, unpoolId, 1); + + Mat input({1, 1, 4, 4}, CV_32F); + randu(input, -1.0f, 1.0f); + net.setInput(input); + Mat outputDefault = net.forward("testUnpool").clone(); + + net.setPreferableBackend(DNN_BACKEND_HALIDE); + net.setInput(input); + Mat outputHalide = net.forward("testUnpool").clone(); + normAssert(outputDefault, outputHalide); +} + +//////////////////////////////////////////////////////////////////////////////// +// AvePooling + in-place layers +//////////////////////////////////////////////////////////////////////////////// +static const int kNumChannels = 3; + +void testInPlaceActivation(LayerParams& lp) +{ + EXPECT_FALSE(lp.name.empty()); + + LayerParams pool; + pool.set("pool", "ave"); + pool.set("kernel_w", 2); + pool.set("kernel_h", 2); + pool.set("stride_w", 2); + pool.set("stride_h", 2); + pool.type = "Pooling"; + + Net net; + int poolId = net.addLayer(pool.name, pool.type, pool); + net.connect(0, 0, poolId, 0); + net.addLayerToPrev(lp.name, lp.type, lp); + + Mat input({1, kNumChannels, 10, 10}, CV_32F); + randu(input, -1.0f, 1.0f); + net.setInput(input); + Mat outputDefault = net.forward(lp.name).clone(); + + net.setInput(input); + net.setPreferableBackend(DNN_BACKEND_HALIDE); + Mat outputHalide = net.forward(lp.name).clone(); + normAssert(outputDefault, outputHalide); +} + +typedef TestWithParam > BatchNorm; +TEST_P(BatchNorm, Accuracy) +{ + bool hasWeights = get<0>(GetParam()); + bool hasBias = get<1>(GetParam()); + float epsilon = get<2>(GetParam()); + + LayerParams lp; + lp.set("has_weight", hasWeights); + lp.set("has_bias", hasBias); + lp.set("eps", epsilon); + lp.type = "BatchNorm"; + lp.name = "testLayer"; + + lp.blobs.reserve(4); + for (int i = 0; i < 3; ++i) + lp.blobs.push_back(Mat({kNumChannels}, CV_32F)); + if (hasBias || hasWeights) + lp.blobs.push_back(Mat({kNumChannels}, CV_32F)); + + for (Mat& m : lp.blobs) + randu(m, 0.0f, 1.0f); + + testInPlaceActivation(lp); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, BatchNorm, Combine( +/*has weights*/ Bool(), +/*has bias*/ Bool(), +/*epsilon*/ Values(1e-3f, 1e-5f) +)); + +typedef TestWithParam > ReLU; +TEST_P(ReLU, Accuracy) +{ + float negativeSlope = get<0>(GetParam()); + + LayerParams lp; + lp.set("negative_slope", negativeSlope); + lp.type = "ReLU"; + lp.name = "testLayer"; + testInPlaceActivation(lp); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, ReLU, Values( +/*negative slope*/ 2.0f, 0.3f, -0.1f +)); + +typedef TestWithParam > NoParamActivation; +TEST_P(NoParamActivation, Accuracy) +{ + LayerParams lp; + lp.type = get<0>(GetParam()); + lp.name = "testLayer"; + testInPlaceActivation(lp); +} +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, NoParamActivation, Values( +/*type*/ "TanH", "Sigmoid", "AbsVal", "BNLL" +)); + +typedef TestWithParam > Power; +TEST_P(Power, Accuracy) +{ + float power = get<0>(GetParam())[0]; + float scale = get<0>(GetParam())[1]; + float shift = get<0>(GetParam())[2]; + + LayerParams lp; + lp.set("power", power); + lp.set("scale", scale); + lp.set("shift", shift); + lp.type = "Power"; + lp.name = "testLayer"; + testInPlaceActivation(lp); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Power, +/*power, scale, shift*/ Values(Vec3f(0.9f, 1.0f, 1.1f), Vec3f(0.9f, 1.1f, 1.0f), + Vec3f(1.0f, 0.9f, 1.1f), Vec3f(1.0f, 1.1f, 0.9f), + Vec3f(1.1f, 0.9f, 1.0f), Vec3f(1.1f, 1.0f, 0.9f)) +); + +TEST(ChannelsPReLU, Accuracy) +{ + LayerParams lp; + lp.type = "ChannelsPReLU"; + lp.name = "testLayer"; + lp.blobs.push_back(Mat({kNumChannels}, CV_32F)); + randu(lp.blobs[0], -1.0f, 1.0f); + + testInPlaceActivation(lp); +} + +typedef TestWithParam > Scale; +TEST_P(Scale, Accuracy) +{ + bool hasBias = get<0>(GetParam()); + + LayerParams lp; + lp.set("bias_term", hasBias); + lp.type = "Scale"; + lp.name = "testLayer"; + lp.blobs.push_back(Mat({kNumChannels}, CV_32F)); + randu(lp.blobs[0], -1.0f, 1.0f); + if (hasBias) + { + lp.blobs.push_back(Mat({kNumChannels}, CV_32F)); + randu(lp.blobs[1], -1.0f, 1.0f); + } + testInPlaceActivation(lp); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Scale, Values(true, false)); + +//////////////////////////////////////////////////////////////////////////////// +// Concat layer +//////////////////////////////////////////////////////////////////////////////// +// +// input --- conv --- concat --- output +// `--- conv ----^ ^ ^ +// `---- ... ------' ' +// `-----------------' +typedef TestWithParam > Concat; +TEST_P(Concat, Accuracy) +{ + Vec3i inSize = get<0>(GetParam()); + Vec3i numChannels = get<1>(GetParam()); + + Net net; + + LayerParams concatParam; + concatParam.type = "Concat"; + concatParam.name = "testLayer"; + int concatId = net.addLayer(concatParam.name, concatParam.type, concatParam); + net.connect(0, 0, concatId, 0); + + for (int i = 0, n = numChannels.channels; i < n; ++i) + { + if (!numChannels[i]) + break; + + Mat weights({numChannels[i], inSize[0], 1, 1}, CV_32F); + randu(weights, -1.0f, 1.0f); + + LayerParams convParam; + convParam.set("kernel_w", 1); + convParam.set("kernel_h", 1); + convParam.set("num_output", numChannels[i]); + convParam.set("bias_term", false); + convParam.type = "Convolution"; + std::ostringstream ss; + ss << "convLayer" << i; + convParam.name = ss.str(); + convParam.blobs.push_back(weights); + + int convId = net.addLayer(convParam.name, convParam.type, convParam); + net.connect(0, 0, convId, 0); + net.connect(convId, 0, concatId, i + 1); + } + + Mat input({1, inSize[0], inSize[1], inSize[2]}, CV_32F); + randu(input, -1.0f, 1.0f); + + net.setInput(input); + Mat outputDefault = net.forward(concatParam.name).clone(); + + net.setPreferableBackend(DNN_BACKEND_HALIDE); + Mat outputHalide = net.forward(concatParam.name).clone(); + normAssert(outputDefault, outputHalide); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Concat, Combine( +/*input size*/ Values(Vec3i(1, 4, 5), Vec3i(2, 8, 6)), +/*channels*/ Values(Vec3i(2, 0, 0), Vec3i(3, 4, 0), Vec3i(1, 6, 2)) +)); + +//////////////////////////////////////////////////////////////////////////////// +// Element-wise layers +//////////////////////////////////////////////////////////////////////////////// +// +// input --- conv --- eltwise --- output +// `--- conv ----^ ^ ^ +// `---- ... ------' ' +// `-----------------' +typedef TestWithParam > Eltwise; +TEST_P(Eltwise, Accuracy) +{ + Vec3i inSize = get<0>(GetParam()); + std::string op = get<1>(GetParam()); + int numConv = get<2>(GetParam()); + + Net net; + + LayerParams eltwiseParam; + eltwiseParam.type = "Eltwise"; + eltwiseParam.name = "testLayer"; + int eltwiseId = net.addLayer(eltwiseParam.name, eltwiseParam.type, eltwiseParam); + net.connect(0, 0, eltwiseId, 0); + + for (int i = 0; i < numConv; ++i) + { + Mat weights({inSize[0], inSize[0], 1, 1}, CV_32F); + randu(weights, -1.0f, 1.0f); + + LayerParams convParam; + convParam.set("kernel_w", 1); + convParam.set("kernel_h", 1); + convParam.set("num_output", inSize[0]); + convParam.set("bias_term", false); + convParam.type = "Convolution"; + std::ostringstream ss; + ss << "convLayer" << i; + convParam.name = ss.str(); + convParam.blobs.push_back(weights); + + int convId = net.addLayer(convParam.name, convParam.type, convParam); + net.connect(0, 0, convId, 0); + net.connect(convId, 0, eltwiseId, i + 1); + } + + Mat input({1, inSize[0], inSize[1], inSize[2]}, CV_32F); + randu(input, -1.0f, 1.0f); + + net.setInput(input); + Mat outputDefault = net.forward(eltwiseParam.name).clone(); + + net.setPreferableBackend(DNN_BACKEND_HALIDE); + Mat outputHalide = net.forward(eltwiseParam.name).clone(); + normAssert(outputDefault, outputHalide); +} + +INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Eltwise, Combine( +/*input size*/ Values(Vec3i(1, 4, 5), Vec3i(2, 8, 6)), +/*operation*/ Values("prod", "sum", "max"), +/*num convs*/ Values(1, 2, 3) +)); +#endif // HAVE_HALIDE + +} // namespace cvtest diff --git a/modules/dnn/test/test_halide_nets.cpp b/modules/dnn/test/test_halide_nets.cpp new file mode 100644 index 0000000000..206a71c95a --- /dev/null +++ b/modules/dnn/test/test_halide_nets.cpp @@ -0,0 +1,173 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2017, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +namespace cvtest +{ + +#ifdef HAVE_HALIDE +using namespace cv; +using namespace dnn; + +static void loadNet(const std::string& weights, const std::string& proto, + const std::string& framework, Net* net) +{ + if (framework == "caffe") + { + *net = cv::dnn::readNetFromCaffe(proto, weights); + } + else if (framework == "torch") + { + *net = cv::dnn::readNetFromTorch(weights); + } + else if (framework == "tensorflow") + { + *net = cv::dnn::readNetFromTensorflow(weights); + } + else + CV_Error(Error::StsNotImplemented, "Unknown framework " + framework); +} + +static void test(const std::string& weights, const std::string& proto, + const std::string& scheduler, int inWidth, int inHeight, + const std::string& outputLayer, const std::string& framework, + int targetId, double l1 = 1e-5, double lInf = 1e-4) +{ + Mat input(inHeight, inWidth, CV_32FC3), outputDefault, outputHalide; + randu(input, 0.0f, 1.0f); + + Net netDefault, netHalide; + loadNet(weights, proto, framework, &netDefault); + loadNet(weights, proto, framework, &netHalide); + + netDefault.setInput(blobFromImage(input.clone(), 1.0f, Size(), Scalar(), false)); + outputDefault = netDefault.forward(outputLayer).clone(); + + netHalide.setInput(blobFromImage(input.clone(), 1.0f, Size(), Scalar(), false)); + netHalide.setPreferableBackend(DNN_BACKEND_HALIDE); + netHalide.setPreferableTarget(targetId); + netHalide.setHalideScheduler(scheduler); + outputHalide = netHalide.forward(outputLayer).clone(); + + normAssert(outputDefault, outputHalide, "First run", l1, lInf); + + // An extra test: change input. + input *= 0.1f; + netDefault.setInput(blobFromImage(input.clone(), 1.0, Size(), Scalar(), false)); + netHalide.setInput(blobFromImage(input.clone(), 1.0, Size(), Scalar(), false)); + + normAssert(outputDefault, outputHalide, "Second run", l1, lInf); + + // Swap backends. + netHalide.setPreferableBackend(DNN_BACKEND_DEFAULT); + netHalide.setPreferableTarget(DNN_TARGET_CPU); + outputDefault = netHalide.forward(outputLayer).clone(); + + netDefault.setPreferableBackend(DNN_BACKEND_HALIDE); + netDefault.setPreferableTarget(targetId); + netDefault.setHalideScheduler(scheduler); + outputHalide = netDefault.forward(outputLayer).clone(); + + normAssert(outputDefault, outputHalide, "Swap backends", l1, lInf); +} + +//////////////////////////////////////////////////////////////////////////////// +// CPU target +//////////////////////////////////////////////////////////////////////////////// +TEST(Reproducibility_GoogLeNet_Halide, Accuracy) +{ + test(findDataFile("dnn/bvlc_googlenet.caffemodel", false), + findDataFile("dnn/bvlc_googlenet.prototxt", false), + "", 227, 227, "prob", "caffe", DNN_TARGET_CPU); +}; + +TEST(Reproducibility_AlexNet_Halide, Accuracy) +{ + test(findDataFile("dnn/bvlc_alexnet.caffemodel", false), + findDataFile("dnn/bvlc_alexnet.prototxt", false), + findDataFile("dnn/halide_scheduler_alexnet.yml", false), + 227, 227, "prob", "caffe", DNN_TARGET_CPU); +}; + +TEST(Reproducibility_ResNet_50_Halide, Accuracy) +{ + test(findDataFile("dnn/ResNet-50-model.caffemodel", false), + findDataFile("dnn/ResNet-50-deploy.prototxt", false), + findDataFile("dnn/halide_scheduler_resnet_50.yml", false), + 224, 224, "prob", "caffe", DNN_TARGET_CPU); +}; + +TEST(Reproducibility_SqueezeNet_v1_1_Halide, Accuracy) +{ + test(findDataFile("dnn/squeezenet_v1_1.caffemodel", false), + findDataFile("dnn/squeezenet_v1_1.prototxt", false), + findDataFile("dnn/halide_scheduler_squeezenet_v1_1.yml", false), + 227, 227, "prob", "caffe", DNN_TARGET_CPU); +}; + +TEST(Reproducibility_Inception_5h_Halide, Accuracy) +{ + test(findDataFile("dnn/tensorflow_inception_graph.pb", false), "", + findDataFile("dnn/halide_scheduler_inception_5h.yml", false), + 224, 224, "softmax2", "tensorflow", DNN_TARGET_CPU); +}; + +TEST(Reproducibility_ENet_Halide, Accuracy) +{ + test(findDataFile("dnn/Enet-model-best.net", false), "", + findDataFile("dnn/halide_scheduler_enet.yml", false), + 512, 512, "l367_Deconvolution", "torch", DNN_TARGET_CPU, 2e-5, 0.15); +}; +//////////////////////////////////////////////////////////////////////////////// +// OpenCL target +//////////////////////////////////////////////////////////////////////////////// +TEST(Reproducibility_GoogLeNet_Halide_opencl, Accuracy) +{ + test(findDataFile("dnn/bvlc_googlenet.caffemodel", false), + findDataFile("dnn/bvlc_googlenet.prototxt", false), + "", 227, 227, "prob", "caffe", DNN_TARGET_OPENCL); +}; + +TEST(Reproducibility_AlexNet_Halide_opencl, Accuracy) +{ + test(findDataFile("dnn/bvlc_alexnet.caffemodel", false), + findDataFile("dnn/bvlc_alexnet.prototxt", false), + findDataFile("dnn/halide_scheduler_opencl_alexnet.yml", false), + 227, 227, "prob", "caffe", DNN_TARGET_OPENCL); +}; + +TEST(Reproducibility_ResNet_50_Halide_opencl, Accuracy) +{ + test(findDataFile("dnn/ResNet-50-model.caffemodel", false), + findDataFile("dnn/ResNet-50-deploy.prototxt", false), + findDataFile("dnn/halide_scheduler_opencl_resnet_50.yml", false), + 224, 224, "prob", "caffe", DNN_TARGET_OPENCL); +}; + +TEST(Reproducibility_SqueezeNet_v1_1_Halide_opencl, Accuracy) +{ + test(findDataFile("dnn/squeezenet_v1_1.caffemodel", false), + findDataFile("dnn/squeezenet_v1_1.prototxt", false), + findDataFile("dnn/halide_scheduler_opencl_squeezenet_v1_1.yml", false), + 227, 227, "prob", "caffe", DNN_TARGET_OPENCL); +}; + +TEST(Reproducibility_Inception_5h_Halide_opencl, Accuracy) +{ + test(findDataFile("dnn/tensorflow_inception_graph.pb", false), "", + findDataFile("dnn/halide_scheduler_opencl_inception_5h.yml", false), + 224, 224, "softmax2", "tensorflow", DNN_TARGET_OPENCL); +}; + +TEST(Reproducibility_ENet_Halide_opencl, Accuracy) +{ + test(findDataFile("dnn/Enet-model-best.net", false), "", + findDataFile("dnn/halide_scheduler_opencl_enet.yml", false), + 512, 512, "l367_Deconvolution", "torch", DNN_TARGET_OPENCL, 2e-5, 0.14); +}; +#endif // HAVE_HALIDE + +} // namespace cvtest diff --git a/modules/dnn/test/test_layers.cpp b/modules/dnn/test/test_layers.cpp new file mode 100644 index 0000000000..14c984f189 --- /dev/null +++ b/modules/dnn/test/test_layers.cpp @@ -0,0 +1,417 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" +#include +#include +#include "npy_blob.hpp" +#include +#include +#include + +namespace cvtest +{ + +using namespace cv; +using namespace cv::dnn; + +template +static String _tf(TString filename) +{ + String basetestdir = getOpenCVExtraDir(); + size_t len = basetestdir.size(); + if(len > 0 && basetestdir[len-1] != '/' && basetestdir[len-1] != '\\') + return (basetestdir + "/dnn/layers") + filename; + return (basetestdir + "dnn/layers/") + filename; +} + +void runLayer(Ptr layer, std::vector &inpBlobs, std::vector &outBlobs) +{ + size_t i, ninputs = inpBlobs.size(); + std::vector inp_(ninputs); + std::vector inp(ninputs); + std::vector outp, intp; + std::vector inputs, outputs, internals; + + for( i = 0; i < ninputs; i++ ) + { + inp_[i] = inpBlobs[i].clone(); + inp[i] = &inp_[i]; + inputs.push_back(shape(inp_[i])); + } + + layer->getMemoryShapes(inputs, 0, outputs, internals); + for(int i = 0; i < outputs.size(); i++) + { + outp.push_back(Mat(outputs[i], CV_32F)); + } + for(int i = 0; i < internals.size(); i++) + { + intp.push_back(Mat(internals[i], CV_32F)); + } + + layer->finalize(inp, outp); + layer->forward(inp, outp, intp); + + size_t noutputs = outp.size(); + outBlobs.resize(noutputs); + for( i = 0; i < noutputs; i++ ) + outBlobs[i] = outp[i]; +} + + +void testLayerUsingCaffeModels(String basename, bool useCaffeModel = false, bool useCommonInputBlob = true) +{ + String prototxt = _tf(basename + ".prototxt"); + String caffemodel = _tf(basename + ".caffemodel"); + + String inpfile = (useCommonInputBlob) ? _tf("blob.npy") : _tf(basename + ".input.npy"); + String outfile = _tf(basename + ".npy"); + + cv::setNumThreads(cv::getNumberOfCPUs()); + + Net net; + { + Ptr importer = createCaffeImporter(prototxt, (useCaffeModel) ? caffemodel : String()); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat inp = blobFromNPY(inpfile); + Mat ref = blobFromNPY(outfile); + + net.setInput(inp, "input"); + Mat out = net.forward("output"); + + normAssert(ref, out); +} + +TEST(Layer_Test_Softmax, Accuracy) +{ + testLayerUsingCaffeModels("layer_softmax"); +} + +TEST(Layer_Test_LRN_spatial, Accuracy) +{ + testLayerUsingCaffeModels("layer_lrn_spatial"); +} + +TEST(Layer_Test_LRN_channels, Accuracy) +{ + testLayerUsingCaffeModels("layer_lrn_channels"); +} + +TEST(Layer_Test_Convolution, Accuracy) +{ + testLayerUsingCaffeModels("layer_convolution", true); +} + +TEST(Layer_Test_DeConvolution, Accuracy) +{ + testLayerUsingCaffeModels("layer_deconvolution", true, false); +} + +TEST(Layer_Test_InnerProduct, Accuracy) +{ + testLayerUsingCaffeModels("layer_inner_product", true); +} + +TEST(Layer_Test_Pooling_max, Accuracy) +{ + testLayerUsingCaffeModels("layer_pooling_max"); +} + +TEST(Layer_Test_Pooling_ave, Accuracy) +{ + testLayerUsingCaffeModels("layer_pooling_ave"); +} + +TEST(Layer_Test_MVN, Accuracy) +{ + testLayerUsingCaffeModels("layer_mvn"); +} + +void testReshape(const MatShape& inputShape, const MatShape& targetShape, + int axis = 0, int num_axes = -1, bool reorder_dims = false, + MatShape mask = MatShape()) +{ + LayerParams params; + params.set("axis", axis); + params.set("num_axes", num_axes); + params.set("reorder_dims", reorder_dims); + if (!mask.empty()) + { + params.set("dim", DictValue::arrayInt(&mask[0], mask.size())); + } + + Mat inp(inputShape.size(), &inputShape[0], CV_32F); + std::vector inpVec(1, inp); + std::vector outVec, intVec; + + Ptr rl = LayerFactory::createLayerInstance("Reshape", params); + runLayer(rl, inpVec, outVec); + + Mat& out = outVec[0]; + MatShape shape(out.size.p, out.size.p + out.dims); + EXPECT_EQ(shape, targetShape); +} + +TEST(Layer_Test_Reshape, Accuracy) +{ + { + int inp[] = {4, 3, 1, 2}; + int out[] = {4, 3, 2}; + testReshape(MatShape(inp, inp + 4), MatShape(out, out + 3), 2, 1); + } + { + int inp[] = {1, 128, 4, 4}; + int out[] = {1, 2048}; + int mask[] = {-1, 2048}; + testReshape(MatShape(inp, inp + 4), MatShape(out, out + 2), 0, -1, true, + MatShape(mask, mask + 2)); + } +} + +TEST(Layer_Test_BatchNorm, Accuracy) +{ + testLayerUsingCaffeModels("layer_batch_norm", true); +} + +TEST(Layer_Test_ReLU, Accuracy) +{ + testLayerUsingCaffeModels("layer_relu"); +} + +TEST(Layer_Test_Dropout, Accuracy) +{ + testLayerUsingCaffeModels("layer_dropout"); +} + +TEST(Layer_Test_Concat, Accuracy) +{ + testLayerUsingCaffeModels("layer_concat"); +} + +//template +//static void test_Layer_Concat() +//{ +// Matx21f a(1.f, 1.f), b(2.f, 2.f), c(3.f, 3.f); +// std::vector res(1), src = { Blob(XMat(a)), Blob(XMat(b)), Blob(XMat(c)) }; +// Blob ref(XMat(Matx23f(1.f, 2.f, 3.f, 1.f, 2.f, 3.f))); +// +// runLayer(ConcatLayer::create(1), src, res); +// normAssert(ref, res[0]); +//} +//TEST(Layer_Concat, Accuracy) +//{ +// test_Layer_Concat()); +//} +//OCL_TEST(Layer_Concat, Accuracy) +//{ +// OCL_ON(test_Layer_Concat()); +// ); +//} + +static void test_Reshape_Split_Slice_layers() +{ + Net net; + { + Ptr importer = createCaffeImporter(_tf("reshape_and_slice_routines.prototxt")); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat input(6, 12, CV_32F); + RNG rng(0); + rng.fill(input, RNG::UNIFORM, -1, 1); + + net.setInput(input, "input"); + Mat output = net.forward("output"); + + normAssert(input, output); +} +TEST(Layer_Test_Reshape_Split_Slice, Accuracy) +{ + test_Reshape_Split_Slice_layers(); +} + +class Layer_LSTM_Test : public ::testing::Test +{ +public: + int numInp, numOut; + Mat Wh, Wx, b; + Ptr layer; + std::vector inputs, outputs; + + Layer_LSTM_Test() {} + + void init(const MatShape &inpShape_, const MatShape &outShape_) + { + numInp = total(inpShape_); + numOut = total(outShape_); + + Wh = Mat::ones(4 * numOut, numOut, CV_32F); + Wx = Mat::ones(4 * numOut, numInp, CV_32F); + b = Mat::ones(4 * numOut, 1, CV_32F); + + layer = LSTMLayer::create(LayerParams()); + layer->setWeights(Wh, Wx, b); + layer->setOutShape(outShape_); + } +}; + +TEST_F(Layer_LSTM_Test, get_set_test) +{ + const int TN = 4; + MatShape inpShape = shape(5, 3, 2); + MatShape outShape = shape(3, 1, 2); + MatShape inpResShape = concat(shape(TN), inpShape); + MatShape outResShape = concat(shape(TN), outShape); + + init(inpShape, outShape); + layer->setProduceCellOutput(true); + layer->setUseTimstampsDim(false); + layer->setOutShape(outShape); + + Mat C((int)outResShape.size(), &outResShape[0], CV_32F); + randu(C, -1., 1.); + Mat H = C.clone(); + randu(H, -1., 1.); + + Mat inp((int)inpResShape.size(), &inpResShape[0], CV_32F); + randu(inp, -1., 1.); + + inputs.push_back(inp); + runLayer(layer, inputs, outputs); + + EXPECT_EQ(2u, outputs.size()); + + print(outResShape, "outResShape"); + print(shape(outputs[0]), "out0"); + print(shape(outputs[0]), "out1"); + + EXPECT_EQ(outResShape, shape(outputs[0])); + EXPECT_EQ(outResShape, shape(outputs[1])); + + EXPECT_EQ(0, layer->inputNameToIndex("x")); + EXPECT_EQ(0, layer->outputNameToIndex("h")); + EXPECT_EQ(1, layer->outputNameToIndex("c")); +} + +TEST(Layer_LSTM_Test_Accuracy_with_, CaffeRecurrent) +{ + Ptr layer = LSTMLayer::create(LayerParams()); + + Mat Wx = blobFromNPY(_tf("lstm.prototxt.w_0.npy")); + Mat Wh = blobFromNPY(_tf("lstm.prototxt.w_2.npy")); + Mat b = blobFromNPY(_tf("lstm.prototxt.w_1.npy")); + layer->setWeights(Wh, Wx, b); + + Mat inp = blobFromNPY(_tf("recurrent.input.npy")); + std::vector inputs(1, inp), outputs; + runLayer(layer, inputs, outputs); + + Mat h_t_reference = blobFromNPY(_tf("lstm.prototxt.h_1.npy")); + normAssert(h_t_reference, outputs[0]); +} + +TEST(Layer_RNN_Test_Accuracy_with_, CaffeRecurrent) +{ + Ptr layer = RNNLayer::create(LayerParams()); + + layer->setWeights( + blobFromNPY(_tf("rnn.prototxt.w_0.npy")), + blobFromNPY(_tf("rnn.prototxt.w_1.npy")), + blobFromNPY(_tf("rnn.prototxt.w_2.npy")), + blobFromNPY(_tf("rnn.prototxt.w_3.npy")), + blobFromNPY(_tf("rnn.prototxt.w_4.npy")) ); + + std::vector output, input(1, blobFromNPY(_tf("recurrent.input.npy"))); + runLayer(layer, input, output); + + Mat h_ref = blobFromNPY(_tf("rnn.prototxt.h_1.npy")); + normAssert(h_ref, output[0]); +} + + +class Layer_RNN_Test : public ::testing::Test +{ +public: + int nX, nH, nO, nT, nS; + Mat Whh, Wxh, bh, Who, bo; + Ptr layer; + + std::vector inputs, outputs; + + Layer_RNN_Test() + { + nT = 3; + nS = 5; + nX = 31; + nH = 64; + nO = 100; + + Whh = Mat::ones(nH, nH, CV_32F); + Wxh = Mat::ones(nH, nX, CV_32F); + bh = Mat::ones(nH, 1, CV_32F); + Who = Mat::ones(nO, nH, CV_32F); + bo = Mat::ones(nO, 1, CV_32F); + + layer = RNNLayer::create(LayerParams()); + layer->setProduceHiddenOutput(true); + layer->setWeights(Wxh, bh, Whh, Who, bo); + } +}; + +TEST_F(Layer_RNN_Test, get_set_test) +{ + int sz[] = { nT, nS, 1, nX }; + Mat inp(4, sz, CV_32F); + randu(inp, -1., 1.); + inputs.push_back(inp); + runLayer(layer, inputs, outputs); + + EXPECT_EQ(outputs.size(), 2u); + EXPECT_EQ(shape(outputs[0]), shape(nT, nS, nO)); + EXPECT_EQ(shape(outputs[1]), shape(nT, nS, nH)); +} + +} diff --git a/modules/dnn/test/test_main.cpp b/modules/dnn/test/test_main.cpp new file mode 100644 index 0000000000..ead7916a05 --- /dev/null +++ b/modules/dnn/test/test_main.cpp @@ -0,0 +1,20 @@ +#include "test_precomp.hpp" + +static const char* extraTestDataPath = +#ifdef WINRT + NULL; +#else + getenv("OPENCV_DNN_TEST_DATA_PATH"); +#endif + +CV_TEST_MAIN("", + extraTestDataPath ? (void)cvtest::addDataSearchPath(extraTestDataPath) : (void)0 +) + +namespace cvtest +{ + +using namespace cv; +using namespace cv::dnn; + +} diff --git a/modules/dnn/test/test_precomp.hpp b/modules/dnn/test/test_precomp.hpp new file mode 100644 index 0000000000..ee13ebe190 --- /dev/null +++ b/modules/dnn/test/test_precomp.hpp @@ -0,0 +1,62 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wmissing-declarations" +# if defined __clang__ || defined __APPLE__ +# pragma GCC diagnostic ignored "-Wmissing-prototypes" +# pragma GCC diagnostic ignored "-Wextra" +# endif +#endif + +#ifndef __OPENCV_TEST_PRECOMP_HPP__ +#define __OPENCV_TEST_PRECOMP_HPP__ + +#include "opencv2/core.hpp" +#include "opencv2/dnn.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/ts.hpp" +#include +#include +#include "test_common.hpp" + +#endif diff --git a/modules/dnn/test/test_tf_importer.cpp b/modules/dnn/test/test_tf_importer.cpp new file mode 100644 index 0000000000..fbddc15f59 --- /dev/null +++ b/modules/dnn/test/test_tf_importer.cpp @@ -0,0 +1,74 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2016, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +/* +Test for Tensorflow models loading +*/ + +#include "test_precomp.hpp" +#include "npy_blob.hpp" + +namespace cvtest +{ + +using namespace cv; +using namespace cv::dnn; + +template +static std::string _tf(TString filename) +{ + return (getOpenCVExtraDir() + "/dnn/") + filename; +} + +TEST(Test_TensorFlow, read_inception) +{ + Net net; + { + const string model = findDataFile("dnn/tensorflow_inception_graph.pb", false); + Ptr importer = createTensorflowImporter(model); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat sample = imread(_tf("grace_hopper_227.png")); + ASSERT_TRUE(!sample.empty()); + Mat input; + resize(sample, input, Size(224, 224)); + input -= 128; // mean sub + + Mat inputBlob = blobFromImage(input); + + net.setInput(inputBlob, "input"); + Mat out = net.forward("softmax2"); + + std::cout << out.dims << std::endl; +} + +TEST(Test_TensorFlow, inception_accuracy) +{ + Net net; + { + const string model = findDataFile("dnn/tensorflow_inception_graph.pb", false); + Ptr importer = createTensorflowImporter(model); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat sample = imread(_tf("grace_hopper_227.png")); + ASSERT_TRUE(!sample.empty()); + resize(sample, sample, Size(224, 224)); + Mat inputBlob = blobFromImage(sample); + + net.setInput(inputBlob, "input"); + Mat out = net.forward("softmax2"); + + Mat ref = blobFromNPY(_tf("tf_inception_prob.npy")); + + normAssert(ref, out); +} + +} diff --git a/modules/dnn/test/test_torch_importer.cpp b/modules/dnn/test/test_torch_importer.cpp new file mode 100644 index 0000000000..5fc3c076ba --- /dev/null +++ b/modules/dnn/test/test_torch_importer.cpp @@ -0,0 +1,207 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#ifdef ENABLE_TORCH_IMPORTER + +#include "test_precomp.hpp" +#include "npy_blob.hpp" +#include + +namespace cvtest +{ + +using namespace std; +using namespace testing; +using namespace cv; +using namespace cv::dnn; + +template +static std::string _tf(TStr filename, bool inTorchDir = true) +{ + String path = getOpenCVExtraDir() + "/dnn/"; + if (inTorchDir) + path += "torch/"; + path += filename; + return path; +} + +TEST(Torch_Importer, simple_read) +{ + Net net; + Ptr importer; + + ASSERT_NO_THROW( importer = createTorchImporter(_tf("net_simple_net.txt"), false) ); + ASSERT_TRUE( importer != NULL ); + importer->populateNet(net); +} + +static void runTorchNet(String prefix, String outLayerName = "", + bool check2ndBlob = false, bool isBinary = false) +{ + String suffix = (isBinary) ? ".dat" : ".txt"; + + Net net; + Ptr importer = createTorchImporter(_tf(prefix + "_net" + suffix), isBinary); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + + Mat inp, outRef; + ASSERT_NO_THROW( inp = readTorchBlob(_tf(prefix + "_input" + suffix), isBinary) ); + ASSERT_NO_THROW( outRef = readTorchBlob(_tf(prefix + "_output" + suffix), isBinary) ); + + if (outLayerName.empty()) + outLayerName = net.getLayerNames().back(); + + net.setInput(inp, "0"); + std::vector outBlobs; + net.forward(outBlobs, outLayerName); + normAssert(outRef, outBlobs[0]); + + if (check2ndBlob) + { + Mat out2 = outBlobs[1]; + Mat ref2 = readTorchBlob(_tf(prefix + "_output_2" + suffix), isBinary); + normAssert(out2, ref2); + } +} + +TEST(Torch_Importer, run_convolution) +{ + runTorchNet("net_conv"); +} + +TEST(Torch_Importer, run_pool_max) +{ + runTorchNet("net_pool_max", "", true); +} + +TEST(Torch_Importer, run_pool_ave) +{ + runTorchNet("net_pool_ave"); +} + +TEST(Torch_Importer, run_reshape) +{ + runTorchNet("net_reshape"); + runTorchNet("net_reshape_batch"); + runTorchNet("net_reshape_single_sample"); +} + +TEST(Torch_Importer, run_linear) +{ + runTorchNet("net_linear_2d"); +} + +TEST(Torch_Importer, run_paralel) +{ + runTorchNet("net_parallel", "l5_torchMerge"); +} + +TEST(Torch_Importer, run_concat) +{ + runTorchNet("net_concat", "l5_torchMerge"); +} + +TEST(Torch_Importer, run_deconv) +{ + runTorchNet("net_deconv"); +} + +TEST(Torch_Importer, run_batch_norm) +{ + runTorchNet("net_batch_norm"); +} + +TEST(Torch_Importer, net_prelu) +{ + runTorchNet("net_prelu"); +} + +TEST(Torch_Importer, net_cadd_table) +{ + runTorchNet("net_cadd_table"); +} + +TEST(Torch_Importer, net_softmax) +{ + runTorchNet("net_softmax"); + runTorchNet("net_softmax_spatial"); +} + +TEST(Torch_Importer, net_logsoftmax) +{ + runTorchNet("net_logsoftmax"); + runTorchNet("net_logsoftmax_spatial"); +} + +TEST(Torch_Importer, ENet_accuracy) +{ + Net net; + { + const string model = findDataFile("dnn/Enet-model-best.net", false); + Ptr importer = createTorchImporter(model, true); + ASSERT_TRUE(importer != NULL); + importer->populateNet(net); + } + + Mat sample = imread(_tf("street.png", false)); + Mat inputBlob = blobFromImage(sample, 1./255); + + net.setInput(inputBlob, ""); + Mat out = net.forward(); + Mat ref = blobFromNPY(_tf("torch_enet_prob.npy", false)); + // Due to numerical instability in Pooling-Unpooling layers (indexes jittering) + // thresholds for ENet must be changed. Accuracy of resuults was checked on + // Cityscapes dataset and difference in mIOU with Torch is 10E-4% + normAssert(ref, out, "", 0.00044, 0.44); + + const int N = 3; + for (int i = 0; i < N; i++) + { + net.setInput(inputBlob, ""); + Mat out = net.forward(); + normAssert(ref, out, "", 0.00044, 0.44); + } +} + +} + +#endif diff --git a/modules/dnn/tutorials/images/build_1.png b/modules/dnn/tutorials/images/build_1.png new file mode 100644 index 0000000000000000000000000000000000000000..855159e87d741ef9b081ce7d3d8195d694e5b972 GIT binary patch literal 32126 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 literal 0 HcmV?d00001 diff --git a/modules/dnn/tutorials/images/build_3.png b/modules/dnn/tutorials/images/build_3.png new file mode 100644 index 0000000000000000000000000000000000000000..102d6e339eb3ef7e8c64fdd2908c7b2df3edf778 GIT binary patch literal 46802 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 literal 0 HcmV?d00001 diff --git a/modules/dnn/tutorials/images/build_4.png b/modules/dnn/tutorials/images/build_4.png new file mode 100644 index 0000000000000000000000000000000000000000..3ad4df8174fb530cd5f52efa725296f6cfb702e5 GIT binary patch literal 40770 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¨RBpt0X?to+K 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%0DxBr;7!AVt& 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 literal 0 HcmV?d00001 diff --git a/modules/dnn/tutorials/tutorial_dnn_build.markdown b/modules/dnn/tutorials/tutorial_dnn_build.markdown new file mode 100644 index 0000000000..36f0fecbf8 --- /dev/null +++ b/modules/dnn/tutorials/tutorial_dnn_build.markdown @@ -0,0 +1,68 @@ +Build opencv_contrib with dnn module {#tutorial_dnn_build} +==================================== + +Introduction +------------ +opencv_dnn module is placed in the secondary [opencv_contrib](https://github.com/opencv/opencv_contrib) repository, +which isn't distributed in binary form, therefore you need to build it manually. + +To do this you need to have installed: [CMake](http://www.cmake.org/download), git, and build system (*gcc* with *make* for Linux or *MS Visual Studio* for Windows) + +Steps +----- +-# Make any directory, for example **opencv_root** + +-# Clone [opencv](https://github.com/opencv/opencv) and [opencv_contrib](https://github.com/opencv/opencv_contrib) repos to the **opencv_root**. + You can do it in terminal like here: +@code +cd opencv_root +git clone https://github.com/opencv/opencv +git clone https://github.com/opencv/opencv_contrib +@endcode + +-# Run [CMake-gui] and set source and build directories: + + - Set source code directory to **opencv_root**/opencv; + + - Set binaries directory, for example, to **opencv_root**/build_opencv. + This directory will contain built libraries. + ![](images/build_1.png) + +-# Configure opencv: + - press *Configure*; + - choose the preferred project generator (Makefiles for Linux, MS Visual Studio for Windows); + - also you can set many opencv build options, for more details see @ref tutorial_linux_install. + ![](images/build_2.png) + +-# In the appeared list of build parameters find parameter `OPENCV_EXTRA_MODULES_PATH` and set it to the **opencv_root**/opencv_contrib. + ![](images/build_3.png) + +-# *Configure* the project again, and set build options of dnn module: + + - `BUILD_opencv_dnn` parameter must exist and be checked. + + - dnn module covers waste part of [Caffe](http://caffe.berkeleyvision.org) framework functionality. + However, to load Caffe networks libprotobuf is required. + You you can uncheck `BUILD_LIBPROTOBUF_FROM_SOURCES` flag to try use protobuf installed in your system. + Elsewise libpotobuf will be built from opencv sources. + + - You can additionally check `opencv_dnn_BUILD_TORCH_IMPORTER` parameter to build [Torch7](http://torch.ch/) importer. + It allows you to use networks, generated by [Torch7.nn](https://github.com/torch/nn/blob/master/README.md/) module. + ![](images/build_4.png) + +-# Press *Configure* and *Generate*. + ![](images/build_5.png) + +-# Build the generated project: + - If Makefiles generator on Unix was used, run the following in terminal: + @code + cd opencv_root/build_opencv + make all + @endcode + - If MS Visual Studio generator was used, then open OpenCV.sln from **opencv_root**/build_opencv folder in the Visual Studio, + and build it by choosing **Build** -> **Build Solution** menu or using **F7** short-cut. + +-# Now you can build own program by using libraries were built into **opencv_root**/build_opencv/lib. + See the following tutorials to learn how to create a program using OpenCV: + - @ref tutorial_windows_install + - @ref tutorial_linux_gcc_cmake \ No newline at end of file diff --git a/modules/dnn/tutorials/tutorial_dnn_googlenet.markdown b/modules/dnn/tutorials/tutorial_dnn_googlenet.markdown new file mode 100644 index 0000000000..01bfca1170 --- /dev/null +++ b/modules/dnn/tutorials/tutorial_dnn_googlenet.markdown @@ -0,0 +1,66 @@ +Load Caffe framework models {#tutorial_dnn_googlenet} +=========================== + +Introduction +------------ + +In this tutorial you will learn how to use opencv_dnn module for image classification by using +GoogLeNet trained network from [Caffe model zoo](http://caffe.berkeleyvision.org/model_zoo.html). + +We will demonstrate results of this example on the following picture. +![Buran space shuttle](images/space_shuttle.jpg) + +Source Code +----------- + +We will be using snippets from the example application, that can be downloaded [here](https://github.com/ludv1x/opencv_contrib/blob/master/modules/dnn/samples/caffe_googlenet.cpp). + +@include dnn/samples/caffe_googlenet.cpp + +Explanation +----------- + +-# Firstly, download GoogLeNet model files: + [bvlc_googlenet.prototxt ](https://raw.githubusercontent.com/ludv1x/opencv_contrib/master/modules/dnn/samples/bvlc_googlenet.prototxt) and + [bvlc_googlenet.caffemodel](http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel) + + Also you need file with names of [ILSVRC2012](http://image-net.org/challenges/LSVRC/2012/browse-synsets) classes: + [synset_words.txt](https://raw.githubusercontent.com/ludv1x/opencv_contrib/master/modules/dnn/samples/synset_words.txt). + + Put these files into working dir of this program example. + +-# Read and initialize network using path to .prototxt and .caffemodel files + @snippet dnn/samples/caffe_googlenet.cpp Read and initialize network + +-# Check that network was read successfully + @snippet dnn/samples/caffe_googlenet.cpp Check that network was read successfully + +-# Read input image and convert to the blob, acceptable by GoogleNet + @snippet dnn/samples/caffe_googlenet.cpp Prepare blob + Firstly, we resize the image and change its channel sequence order. + + Now image is actually a 3-dimensional array with 224x224x3 shape. + + Next, we convert the image to 4-dimensional blob (so-called batch) with 1x3x224x224 shape by using special cv::dnn::blobFromImages constructor. + +-# Pass the blob to the network + @snippet dnn/samples/caffe_googlenet.cpp Set input blob + In bvlc_googlenet.prototxt the network input blob named as "data", therefore this blob labeled as ".data" in opencv_dnn API. + + Other blobs labeled as "name_of_layer.name_of_layer_output". + +-# Make forward pass + @snippet dnn/samples/caffe_googlenet.cpp Make forward pass + During the forward pass output of each network layer is computed, but in this example we need output from "prob" layer only. + +-# Determine the best class + @snippet dnn/samples/caffe_googlenet.cpp Gather output + We put the output of "prob" layer, which contain probabilities for each of 1000 ILSVRC2012 image classes, to the `prob` blob. + And find the index of element with maximal value in this one. This index correspond to the class of the image. + +-# Print results + @snippet dnn/samples/caffe_googlenet.cpp Print results + For our image we get: +> Best class: #812 'space shuttle' +> +> Probability: 99.6378% \ No newline at end of file diff --git a/modules/dnn/tutorials/tutorial_dnn_halide.markdown b/modules/dnn/tutorials/tutorial_dnn_halide.markdown new file mode 100644 index 0000000000..b2a86c82f4 --- /dev/null +++ b/modules/dnn/tutorials/tutorial_dnn_halide.markdown @@ -0,0 +1,132 @@ +# How to enable Halide backend for improve efficiency {#tutorial_dnn_halide} + +## Introduction +This tutorial guidelines how to run your models in OpenCV deep learning module +using Halide language backend. Halide is an open-source project that let us +write image processing algorithms in well-readable format, schedule computations +according to specific device and evaluate it with a quite good efficiency. + +An official website of the Halide project: http://halide-lang.org/. + +## Efficiency comparison +Measured on Intel® Core™ i7-6700K CPU @ 4.00GHz x 8. + +Single image forward pass (in milliseconds): + +| Architecture | MKL backend | Halide backend | Speed Up ratio | +|-----------------:|------------:|---------------:|---------------:| +| AlexNet | 16.55 | 22.38 | x0.73 | +| ResNet-50 | 63.69 | 73.91 | x0.86 | +| SqueezeNet v1.1 | 10.11 | 8.21 | x1.23 | +| Inception-5h | 35.38 | 37.06 | x0.95 | +| ENet @ 3x512x256 | 82.26 | 41.21 | x1.99 | + +Scheduling directives might be found @ [opencv_extra/testdata/dnn](https://github.com/opencv/opencv_extra/tree/master/testdata/dnn). + +## Requirements +### LLVM compiler + +@note LLVM compilation might take a long time. + +- Download LLVM source code from http://releases.llvm.org/4.0.0/llvm-4.0.0.src.tar.xz. +Unpack it. Let **llvm_root** is a root directory of source code. + +- Create directory **llvm_root**/tools/clang + +- Download Clang with the same version as LLVM. In our case it will be from +http://releases.llvm.org/4.0.0/cfe-4.0.0.src.tar.xz. Unpack it into +**llvm_root**/tools/clang. Note that it should be a root for Clang source code. + +- Build LLVM on Linux +@code +cd llvm_root +mkdir build && cd build +cmake -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_TARGETS_TO_BUILD="X86" -DLLVM_ENABLE_ASSERTIONS=ON -DCMAKE_BUILD_TYPE=Release .. +make -j4 +@endcode + +- Build LLVM on Windows (Developer Command Prompt) +@code +mkdir \\path-to-llvm-build\\ && cd \\path-to-llvm-build\\ +cmake.exe -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_ASSERTIONS=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=\\path-to-llvm-install\\ -G "Visual Studio 14 Win64" \\path-to-llvm-src\\ +MSBuild.exe /m:4 /t:Build /p:Configuration=Release .\\INSTALL.vcxproj +@endcode + +@note `\\path-to-llvm-build\\` and `\\path-to-llvm-install\\` are different directories. + +### Halide language. + +- Download source code from GitHub repository, https://github.com/halide/Halide +or using git. The root directory will be a **halide_root**. +@code +git clone https://github.com/halide/Halide.git +@endcode + +- Build Halide on Linux +@code +cd halide_root +mkdir build && cd build +cmake -DLLVM_DIR=llvm_root/build/lib/cmake/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_VERSION=40 -DWITH_TESTS=OFF -DWITH_APPS=OFF -DWITH_TUTORIALS=OFF .. +make -j4 +@endcode + +- Build Halide on Windows (Developer Command Prompt) +@code +cd halide_root +mkdir build && cd build +cmake.exe -DLLVM_DIR=\\path-to-llvm-install\\lib\\cmake\\llvm -DLLVM_VERSION=40 -DWITH_TESTS=OFF -DWITH_APPS=OFF -DWITH_TUTORIALS=OFF -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 14 Win64" .. +MSBuild.exe /m:4 /t:Build /p:Configuration=Release .\\ALL_BUILD.vcxproj +@endcode + +## Build OpenCV with Halide backend +When you build OpenCV add the following configuration flags: + +- `WITH_HALIDE` - enable Halide linkage + +- `HALIDE_ROOT_DIR` - path to Halide build directory + +How to build OpenCV with DNN module you may find in @ref tutorial_dnn_build. + +## Sample + +@include dnn/samples/squeezenet_halide.cpp + +## Explanation +Download Caffe model from SqueezeNet repository: [train_val.prototxt](https://github.com/DeepScale/SqueezeNet/blob/master/SqueezeNet_v1.1/train_val.prototxt) and [squeezenet_v1.1.caffemodel](https://github.com/DeepScale/SqueezeNet/blob/master/SqueezeNet_v1.1/squeezenet_v1.1.caffemodel). + +Also you need file with names of [ILSVRC2012](http://image-net.org/challenges/LSVRC/2012/browse-synsets) classes: +[synset_words.txt](https://raw.githubusercontent.com/ludv1x/opencv_contrib/master/modules/dnn/samples/synset_words.txt). + +Put these files into working dir of this program example. + +-# Read and initialize network using path to .prototxt and .caffemodel files +@snippet dnn/samples/squeezenet_halide.cpp Read and initialize network + +-# Check that network was read successfully +@snippet dnn/samples/squeezenet_halide.cpp Check that network was read successfully + +-# Read input image and convert to the 4-dimensional blob, acceptable by SqueezeNet v1.1 +@snippet dnn/samples/squeezenet_halide.cpp Prepare blob + +-# Pass the blob to the network +@snippet dnn/samples/squeezenet_halide.cpp Set input blob + +-# Enable Halide backend for layers where it is implemented +@snippet dnn/samples/squeezenet_halide.cpp Enable Halide backend + +-# Make forward pass +@snippet dnn/samples/squeezenet_halide.cpp Make forward pass +Remember that the first forward pass after initialization require quite more +time that the next ones. It's because of runtime compilation of Halide pipelines +at the first invocation. + +-# Determine the best class +@snippet dnn/samples/squeezenet_halide.cpp Determine the best class + +-# Print results +@snippet dnn/samples/squeezenet_halide.cpp Print results +For our image we get: + +> Best class: #812 'space shuttle' +> +> Probability: 97.9812% diff --git a/modules/dnn/tutorials/tutorial_dnn_halide_scheduling.markdown b/modules/dnn/tutorials/tutorial_dnn_halide_scheduling.markdown new file mode 100644 index 0000000000..a43ab63e05 --- /dev/null +++ b/modules/dnn/tutorials/tutorial_dnn_halide_scheduling.markdown @@ -0,0 +1,82 @@ +# How to schedule your network for Halide backend {#tutorial_dnn_halide_scheduling} + +## Introduction +Halide code is the same for every device we use. But for achieving the satisfied +efficiency we should schedule computations properly. In this tutorial we describe +the ways to schedule your networks using Halide backend in OpenCV deep learning module. + +For better understanding of Halide scheduling you might want to read tutorials @ http://halide-lang.org/tutorials. + +If it's your first meeting with Halide in OpenCV, we recommend to start from @ref tutorial_dnn_halide. + +## Configuration files +You can schedule computations of Halide pipeline by writing textual configuration files. +It means that you can easily vectorize, parallelize and manage loops order of +layers computation. Pass path to file with scheduling directives for specific +device into ```cv::dnn::Net::setHalideScheduler``` before the first ```cv::dnn::Net::forward``` call. + +Scheduling configuration files represented as YAML files where each node is a +scheduled function or a scheduling directive. +@code +relu1: + reorder: [x, c, y] + split: { y: 2, c: 8 } + parallel: [yo, co] + unroll: yi + vectorize: { x: 4 } +conv1_constant_exterior: + compute_at: { relu1: yi } +@endcode + +Considered use variables `n` for batch dimension, `c` for channels, +`y` for rows and `x` for columns. For variables after split are used names +with the same prefix but `o` and `i` suffixes for outer and inner variables +correspondingly. In example, for variable `x` in range `[0, 10)` directive +`split: { x: 2 }` gives new ones `xo` in range `[0, 5)` and `xi` in range `[0, 2)`. +Variable name `x` is no longer available in the same scheduling node. + +You can find scheduling examples at [opencv_extra/testdata/dnn](https://github.com/opencv/opencv_extra/tree/master/testdata/dnn) +and use it for schedule your networks. + +## Layers fusing +Thanks to layers fusing we can schedule only the top layers of fused sets. +Because for every output value we use the fused formula. +In example, if you have three layers Convolution + Scale + ReLU one by one, +@code +conv(x, y, c, n) = sum(...) + bias(c); +scale(x, y, c, n) = conv(x, y, c, n) * weights(c); +relu(x, y, c, n) = max(scale(x, y, c, n), 0); +@endcode + +fused function is something like +@code +relu(x, y, c, n) = max((sum(...) + bias(c)) * weights(c), 0); +@endcode + +So only function called `relu` require scheduling. + +## Scheduling patterns +Sometimes networks built using blocked structure that means some layer are +identical or quite similar. If you want to apply the same scheduling for +different layers accurate to tiling or vectorization factors, define scheduling +patterns in section `patterns` at the beginning of scheduling file. +Also, your patters may use some parametric variables. +@code +# At the beginning of the file +patterns: + fully_connected: + split: { c: c_split } + fuse: { src: [x, y, co], dst: block } + parallel: block + vectorize: { ci: c_split } +# Somewhere below +fc8: + pattern: fully_connected + params: { c_split: 8 } +@endcode + +## Automatic scheduling +You can let DNN to schedule layers automatically. Just skip call of ```cv::dnn::Net::setHalideScheduler```. Sometimes it might be even more efficient than manual scheduling. +But if specific layers require be scheduled manually, you would be able to +mix both manual and automatic scheduling ways. Write scheduling file +and skip layers that you want to be scheduled automatically. From 7f12836df94fe892c5d08639f057088919a3704f Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 14:21:33 +0300 Subject: [PATCH 02/10] dnn: fix public headers guards --- modules/dnn/include/opencv2/dnn.hpp | 6 +++--- modules/dnn/include/opencv2/dnn/all_layers.hpp | 4 ++-- modules/dnn/include/opencv2/dnn/dict.hpp | 4 ++-- modules/dnn/include/opencv2/dnn/dnn.hpp | 4 ++-- modules/dnn/include/opencv2/dnn/dnn.inl.hpp | 4 ++-- modules/dnn/include/opencv2/dnn/layer.hpp | 4 ++-- modules/dnn/include/opencv2/dnn/shape_utils.hpp | 4 ++-- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/modules/dnn/include/opencv2/dnn.hpp b/modules/dnn/include/opencv2/dnn.hpp index 37be989263..7bad7505a0 100644 --- a/modules/dnn/include/opencv2/dnn.hpp +++ b/modules/dnn/include/opencv2/dnn.hpp @@ -39,8 +39,8 @@ // //M*/ -#ifndef __OPENCV_DNN_HPP__ -#define __OPENCV_DNN_HPP__ +#ifndef OPENCV_DNN_HPP +#define OPENCV_DNN_HPP // This is an umbrealla header to include into you project. // We are free to change headers layout in dnn subfolder, so please include @@ -61,4 +61,4 @@ */ #include -#endif /* __OPENCV_DNN_HPP__ */ +#endif /* OPENCV_DNN_HPP */ diff --git a/modules/dnn/include/opencv2/dnn/all_layers.hpp b/modules/dnn/include/opencv2/dnn/all_layers.hpp index a953e813c2..b3e36e9296 100644 --- a/modules/dnn/include/opencv2/dnn/all_layers.hpp +++ b/modules/dnn/include/opencv2/dnn/all_layers.hpp @@ -39,8 +39,8 @@ // //M*/ -#ifndef __OPENCV_DNN_DNN_ALL_LAYERS_HPP__ -#define __OPENCV_DNN_DNN_ALL_LAYERS_HPP__ +#ifndef OPENCV_DNN_DNN_ALL_LAYERS_HPP +#define OPENCV_DNN_DNN_ALL_LAYERS_HPP #include namespace cv diff --git a/modules/dnn/include/opencv2/dnn/dict.hpp b/modules/dnn/include/opencv2/dnn/dict.hpp index 1096cc0ff2..9a7efb7134 100644 --- a/modules/dnn/include/opencv2/dnn/dict.hpp +++ b/modules/dnn/include/opencv2/dnn/dict.hpp @@ -39,8 +39,8 @@ // //M*/ -#ifndef __OPENCV_DNN_DNN_DICT_HPP__ -#define __OPENCV_DNN_DNN_DICT_HPP__ +#ifndef OPENCV_DNN_DNN_DICT_HPP +#define OPENCV_DNN_DNN_DICT_HPP #include #include diff --git a/modules/dnn/include/opencv2/dnn/dnn.hpp b/modules/dnn/include/opencv2/dnn/dnn.hpp index 7a85da78c2..a705731521 100644 --- a/modules/dnn/include/opencv2/dnn/dnn.hpp +++ b/modules/dnn/include/opencv2/dnn/dnn.hpp @@ -39,8 +39,8 @@ // //M*/ -#ifndef __OPENCV_DNN_DNN_HPP__ -#define __OPENCV_DNN_DNN_HPP__ +#ifndef OPENCV_DNN_DNN_HPP +#define OPENCV_DNN_DNN_HPP #include #include diff --git a/modules/dnn/include/opencv2/dnn/dnn.inl.hpp b/modules/dnn/include/opencv2/dnn/dnn.inl.hpp index 8a3c72ee98..0bfde6f515 100644 --- a/modules/dnn/include/opencv2/dnn/dnn.inl.hpp +++ b/modules/dnn/include/opencv2/dnn/dnn.inl.hpp @@ -39,8 +39,8 @@ // //M*/ -#ifndef __OPENCV_DNN_DNN_INL_HPP__ -#define __OPENCV_DNN_DNN_INL_HPP__ +#ifndef OPENCV_DNN_DNN_INL_HPP +#define OPENCV_DNN_DNN_INL_HPP #include diff --git a/modules/dnn/include/opencv2/dnn/layer.hpp b/modules/dnn/include/opencv2/dnn/layer.hpp index af663dd3e1..443b67d89a 100644 --- a/modules/dnn/include/opencv2/dnn/layer.hpp +++ b/modules/dnn/include/opencv2/dnn/layer.hpp @@ -39,8 +39,8 @@ // //M*/ -#ifndef __OPENCV_DNN_LAYER_HPP__ -#define __OPENCV_DNN_LAYER_HPP__ +#ifndef OPENCV_DNN_LAYER_HPP +#define OPENCV_DNN_LAYER_HPP #include namespace cv diff --git a/modules/dnn/include/opencv2/dnn/shape_utils.hpp b/modules/dnn/include/opencv2/dnn/shape_utils.hpp index 7ecc8dd067..d0a16a1b25 100644 --- a/modules/dnn/include/opencv2/dnn/shape_utils.hpp +++ b/modules/dnn/include/opencv2/dnn/shape_utils.hpp @@ -39,8 +39,8 @@ // //M*/ -#ifndef __OPENCV_DNN_DNN_SHAPE_UTILS_HPP__ -#define __OPENCV_DNN_DNN_SHAPE_UTILS_HPP__ +#ifndef OPENCV_DNN_DNN_SHAPE_UTILS_HPP +#define OPENCV_DNN_DNN_SHAPE_UTILS_HPP #include #include From 6031c79197455363b448efab9ecdb88cbd50a6c2 Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 14:42:38 +0300 Subject: [PATCH 03/10] dnn: remove unused README --- modules/dnn/README.md | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 modules/dnn/README.md diff --git a/modules/dnn/README.md b/modules/dnn/README.md deleted file mode 100644 index 6e7e9c408a..0000000000 --- a/modules/dnn/README.md +++ /dev/null @@ -1,2 +0,0 @@ -Deep Neural Network module -========================== \ No newline at end of file From 14de8ac9515971cfd9cc5ac4dca860c9698bca33 Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 14:36:40 +0300 Subject: [PATCH 04/10] dnn: move samples --- samples/CMakeLists.txt | 2 + .../samples => samples/data/dnn}/.gitignore | 0 ...GG_VOC0712_SSD_300x300_iter_60000.prototxt | 0 .../data/dnn}/bvlc_googlenet.prototxt | 0 .../data/dnn}/enet-classes.txt | 0 .../data/dnn}/fcn32s-heavy-pascal.prototxt | 0 .../data/dnn}/fcn8s-heavy-pascal.prototxt | 0 .../data/dnn}/pascal-classes.txt | 0 .../dnn/samples => samples/data/dnn}/rgb.jpg | Bin .../data/dnn}/space_shuttle.jpg | Bin .../data/dnn}/synset_words.txt | 0 samples/dnn/CMakeLists.txt | 55 ++++++++++++++++++ .../dnn}/caffe_googlenet.cpp | 0 .../samples => samples/dnn}/fcn_semsegm.cpp | 0 .../dnn}/googlenet_python.py | 0 .../dnn}/squeezenet_halide.cpp | 0 .../dnn}/ssd_object_detection.cpp | 0 .../samples => samples/dnn}/tf_inception.cpp | 0 .../samples => samples/dnn}/torch_enet.cpp | 0 19 files changed, 57 insertions(+) rename {modules/dnn/samples => samples/data/dnn}/.gitignore (100%) rename {modules/dnn/samples => samples/data/dnn}/VGG_VOC0712_SSD_300x300_iter_60000.prototxt (100%) rename {modules/dnn/samples => samples/data/dnn}/bvlc_googlenet.prototxt (100%) rename {modules/dnn/samples => samples/data/dnn}/enet-classes.txt (100%) rename {modules/dnn/samples => samples/data/dnn}/fcn32s-heavy-pascal.prototxt (100%) rename {modules/dnn/samples => samples/data/dnn}/fcn8s-heavy-pascal.prototxt (100%) rename {modules/dnn/samples => samples/data/dnn}/pascal-classes.txt (100%) rename {modules/dnn/samples => samples/data/dnn}/rgb.jpg (100%) rename {modules/dnn/samples => samples/data/dnn}/space_shuttle.jpg (100%) rename {modules/dnn/samples => samples/data/dnn}/synset_words.txt (100%) create mode 100644 samples/dnn/CMakeLists.txt rename {modules/dnn/samples => samples/dnn}/caffe_googlenet.cpp (100%) rename {modules/dnn/samples => samples/dnn}/fcn_semsegm.cpp (100%) rename {modules/dnn/samples => samples/dnn}/googlenet_python.py (100%) rename {modules/dnn/samples => samples/dnn}/squeezenet_halide.cpp (100%) rename {modules/dnn/samples => samples/dnn}/ssd_object_detection.cpp (100%) rename {modules/dnn/samples => samples/dnn}/tf_inception.cpp (100%) rename {modules/dnn/samples => samples/dnn}/torch_enet.cpp (100%) diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt index 152d502395..cc2a41bd2c 100644 --- a/samples/CMakeLists.txt +++ b/samples/CMakeLists.txt @@ -11,6 +11,7 @@ if(NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_LIST_DIR) # ---------------------------------------------------------------------------- add_subdirectory(cpp) +add_subdirectory(dnn) add_subdirectory(gpu) add_subdirectory(tapi) @@ -78,6 +79,7 @@ if(MSVC) endif() add_subdirectory(cpp) +add_subdirectory(dnn) # FIXIT: can't use cvconfig.h in samples: add_subdirectory(gpu) add_subdirectory(opencl) diff --git a/modules/dnn/samples/.gitignore b/samples/data/dnn/.gitignore similarity index 100% rename from modules/dnn/samples/.gitignore rename to samples/data/dnn/.gitignore diff --git a/modules/dnn/samples/VGG_VOC0712_SSD_300x300_iter_60000.prototxt b/samples/data/dnn/VGG_VOC0712_SSD_300x300_iter_60000.prototxt similarity index 100% rename from modules/dnn/samples/VGG_VOC0712_SSD_300x300_iter_60000.prototxt rename to samples/data/dnn/VGG_VOC0712_SSD_300x300_iter_60000.prototxt diff --git a/modules/dnn/samples/bvlc_googlenet.prototxt b/samples/data/dnn/bvlc_googlenet.prototxt similarity index 100% rename from modules/dnn/samples/bvlc_googlenet.prototxt rename to samples/data/dnn/bvlc_googlenet.prototxt diff --git a/modules/dnn/samples/enet-classes.txt b/samples/data/dnn/enet-classes.txt similarity index 100% rename from modules/dnn/samples/enet-classes.txt rename to samples/data/dnn/enet-classes.txt diff --git a/modules/dnn/samples/fcn32s-heavy-pascal.prototxt b/samples/data/dnn/fcn32s-heavy-pascal.prototxt similarity index 100% rename from modules/dnn/samples/fcn32s-heavy-pascal.prototxt rename to samples/data/dnn/fcn32s-heavy-pascal.prototxt diff --git a/modules/dnn/samples/fcn8s-heavy-pascal.prototxt b/samples/data/dnn/fcn8s-heavy-pascal.prototxt similarity index 100% rename from modules/dnn/samples/fcn8s-heavy-pascal.prototxt rename to samples/data/dnn/fcn8s-heavy-pascal.prototxt diff --git a/modules/dnn/samples/pascal-classes.txt b/samples/data/dnn/pascal-classes.txt similarity index 100% rename from modules/dnn/samples/pascal-classes.txt rename to samples/data/dnn/pascal-classes.txt diff --git a/modules/dnn/samples/rgb.jpg b/samples/data/dnn/rgb.jpg similarity index 100% rename from modules/dnn/samples/rgb.jpg rename to samples/data/dnn/rgb.jpg diff --git a/modules/dnn/samples/space_shuttle.jpg b/samples/data/dnn/space_shuttle.jpg similarity index 100% rename from modules/dnn/samples/space_shuttle.jpg rename to samples/data/dnn/space_shuttle.jpg diff --git a/modules/dnn/samples/synset_words.txt b/samples/data/dnn/synset_words.txt similarity index 100% rename from modules/dnn/samples/synset_words.txt rename to samples/data/dnn/synset_words.txt diff --git a/samples/dnn/CMakeLists.txt b/samples/dnn/CMakeLists.txt new file mode 100644 index 0000000000..83ac3cd3dc --- /dev/null +++ b/samples/dnn/CMakeLists.txt @@ -0,0 +1,55 @@ +SET(OPENCV_DNN_SAMPLES_REQUIRED_DEPS opencv_core opencv_imgproc opencv_dnn + opencv_imgcodecs opencv_videoio opencv_highgui + ${OpenCV_LIB_COMPONENTS}) + +ocv_check_dependencies(${OPENCV_DNN_SAMPLES_REQUIRED_DEPS}) + + +if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND) + project(dnn_samples) + + ocv_include_directories("${OpenCV_SOURCE_DIR}/include") + ocv_include_modules_recurse(${OPENCV_DNN_SAMPLES_REQUIRED_DEPS}) + + # --------------------------------------------- + # Define executable targets + # --------------------------------------------- + MACRO(OPENCV_DEFINE_DNN_EXAMPLE name srcs) + set(sample_kind example_dnn) + set(sample_subfolder "dnn") + + set(the_target "${sample_kind}_${name}") + add_executable(${the_target} ${srcs}) + ocv_target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_DNN_SAMPLES_REQUIRED_DEPS}) + + set_target_properties(${the_target} PROPERTIES + OUTPUT_NAME "${sample_kind}-${name}" + PROJECT_LABEL "(${sample_KIND}) ${name}") + + if(ENABLE_SOLUTION_FOLDERS) + set_target_properties(${the_target} PROPERTIES FOLDER "samples/${sample_subfolder}") + endif() + + if(WIN32) + if (MSVC AND NOT BUILD_SHARED_LIBS) + set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG") + endif() + install(TARGETS ${the_target} + RUNTIME DESTINATION "${OPENCV_SAMPLES_BIN_INSTALL_PATH}/${sample_subfolder}" COMPONENT samples) + endif() + ENDMACRO() + + file(GLOB_RECURSE dnn_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp) + + foreach(sample_filename ${dnn_samples}) + get_filename_component(sample ${sample_filename} NAME_WE) + OPENCV_DEFINE_DNN_EXAMPLE(${sample} ${sample_filename}) + endforeach() +endif() + +if(INSTALL_C_EXAMPLES AND NOT WIN32) + file(GLOB C_SAMPLES *.c *.cpp *.jpg *.png *.data makefile.* build_all.sh *.dsp *.cmd ) + install(FILES ${C_SAMPLES} + DESTINATION ${OPENCV_SAMPLES_SRC_INSTALL_PATH}/dnn + PERMISSIONS OWNER_READ GROUP_READ WORLD_READ COMPONENT samples) +endif() diff --git a/modules/dnn/samples/caffe_googlenet.cpp b/samples/dnn/caffe_googlenet.cpp similarity index 100% rename from modules/dnn/samples/caffe_googlenet.cpp rename to samples/dnn/caffe_googlenet.cpp diff --git a/modules/dnn/samples/fcn_semsegm.cpp b/samples/dnn/fcn_semsegm.cpp similarity index 100% rename from modules/dnn/samples/fcn_semsegm.cpp rename to samples/dnn/fcn_semsegm.cpp diff --git a/modules/dnn/samples/googlenet_python.py b/samples/dnn/googlenet_python.py similarity index 100% rename from modules/dnn/samples/googlenet_python.py rename to samples/dnn/googlenet_python.py diff --git a/modules/dnn/samples/squeezenet_halide.cpp b/samples/dnn/squeezenet_halide.cpp similarity index 100% rename from modules/dnn/samples/squeezenet_halide.cpp rename to samples/dnn/squeezenet_halide.cpp diff --git a/modules/dnn/samples/ssd_object_detection.cpp b/samples/dnn/ssd_object_detection.cpp similarity index 100% rename from modules/dnn/samples/ssd_object_detection.cpp rename to samples/dnn/ssd_object_detection.cpp diff --git a/modules/dnn/samples/tf_inception.cpp b/samples/dnn/tf_inception.cpp similarity index 100% rename from modules/dnn/samples/tf_inception.cpp rename to samples/dnn/tf_inception.cpp diff --git a/modules/dnn/samples/torch_enet.cpp b/samples/dnn/torch_enet.cpp similarity index 100% rename from modules/dnn/samples/torch_enet.cpp rename to samples/dnn/torch_enet.cpp From 382e38941c0552c7c51ac2122645a3a0b9ee94f2 Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 15:01:30 +0300 Subject: [PATCH 05/10] dnn: fix documentation links --- modules/dnn/test/pascal_semsegm_test_fcn.py | 4 ++-- .../tutorials/tutorial_dnn_googlenet.markdown | 22 +++++++++---------- .../tutorials/tutorial_dnn_halide.markdown | 20 ++++++++--------- samples/dnn/squeezenet_halide.cpp | 2 +- 4 files changed, 24 insertions(+), 24 deletions(-) diff --git a/modules/dnn/test/pascal_semsegm_test_fcn.py b/modules/dnn/test/pascal_semsegm_test_fcn.py index 2a16c72e53..f7d9cd9dd3 100644 --- a/modules/dnn/test/pascal_semsegm_test_fcn.py +++ b/modules/dnn/test/pascal_semsegm_test_fcn.py @@ -205,9 +205,9 @@ if __name__ == "__main__": parser.add_argument("--val_names", help="path to file with validation set image names, download it here: " "https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/data/pascal/seg11valid.txt") parser.add_argument("--cls_file", help="path to file with colors for classes, download it here: " - "https://github.com/opencv/opencv_contrib/blob/master/modules/dnn/samples/pascal-classes.txt") + "https://github.com/opencv/opencv/blob/master/modules/samples/data/dnn/pascal-classes.txt") parser.add_argument("--prototxt", help="path to caffe prototxt, download it here: " - "https://github.com/opencv/opencv_contrib/blob/master/modules/dnn/samples/fcn8s-heavy-pascal.prototxt") + "https://github.com/opencv/opencv/blob/master/modules/samples/data/dnn/fcn8s-heavy-pascal.prototxt") parser.add_argument("--caffemodel", help="path to caffemodel file, download it here: " "http://dl.caffe.berkeleyvision.org/fcn8s-heavy-pascal.caffemodel") parser.add_argument("--log", help="path to logging file") diff --git a/modules/dnn/tutorials/tutorial_dnn_googlenet.markdown b/modules/dnn/tutorials/tutorial_dnn_googlenet.markdown index 01bfca1170..2fdbccd7a5 100644 --- a/modules/dnn/tutorials/tutorial_dnn_googlenet.markdown +++ b/modules/dnn/tutorials/tutorial_dnn_googlenet.markdown @@ -13,30 +13,30 @@ We will demonstrate results of this example on the following picture. Source Code ----------- -We will be using snippets from the example application, that can be downloaded [here](https://github.com/ludv1x/opencv_contrib/blob/master/modules/dnn/samples/caffe_googlenet.cpp). +We will be using snippets from the example application, that can be downloaded [here](https://github.com/opencv/opencv/blob/master/modules/samples/dnn/caffe_googlenet.cpp). -@include dnn/samples/caffe_googlenet.cpp +@include dnn/caffe_googlenet.cpp Explanation ----------- -# Firstly, download GoogLeNet model files: - [bvlc_googlenet.prototxt ](https://raw.githubusercontent.com/ludv1x/opencv_contrib/master/modules/dnn/samples/bvlc_googlenet.prototxt) and + [bvlc_googlenet.prototxt ](https://raw.githubusercontent.com/opencv/opencv/master/modules/samples/data/dnn/bvlc_googlenet.prototxt) and [bvlc_googlenet.caffemodel](http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel) Also you need file with names of [ILSVRC2012](http://image-net.org/challenges/LSVRC/2012/browse-synsets) classes: - [synset_words.txt](https://raw.githubusercontent.com/ludv1x/opencv_contrib/master/modules/dnn/samples/synset_words.txt). + [synset_words.txt](https://raw.githubusercontent.com/opencv/opencv/master/modules/samples/data/dnn/synset_words.txt). Put these files into working dir of this program example. -# Read and initialize network using path to .prototxt and .caffemodel files - @snippet dnn/samples/caffe_googlenet.cpp Read and initialize network + @snippet dnn/caffe_googlenet.cpp Read and initialize network -# Check that network was read successfully - @snippet dnn/samples/caffe_googlenet.cpp Check that network was read successfully + @snippet dnn/caffe_googlenet.cpp Check that network was read successfully -# Read input image and convert to the blob, acceptable by GoogleNet - @snippet dnn/samples/caffe_googlenet.cpp Prepare blob + @snippet dnn/caffe_googlenet.cpp Prepare blob Firstly, we resize the image and change its channel sequence order. Now image is actually a 3-dimensional array with 224x224x3 shape. @@ -44,22 +44,22 @@ Explanation Next, we convert the image to 4-dimensional blob (so-called batch) with 1x3x224x224 shape by using special cv::dnn::blobFromImages constructor. -# Pass the blob to the network - @snippet dnn/samples/caffe_googlenet.cpp Set input blob + @snippet dnn/caffe_googlenet.cpp Set input blob In bvlc_googlenet.prototxt the network input blob named as "data", therefore this blob labeled as ".data" in opencv_dnn API. Other blobs labeled as "name_of_layer.name_of_layer_output". -# Make forward pass - @snippet dnn/samples/caffe_googlenet.cpp Make forward pass + @snippet dnn/caffe_googlenet.cpp Make forward pass During the forward pass output of each network layer is computed, but in this example we need output from "prob" layer only. -# Determine the best class - @snippet dnn/samples/caffe_googlenet.cpp Gather output + @snippet dnn/caffe_googlenet.cpp Gather output We put the output of "prob" layer, which contain probabilities for each of 1000 ILSVRC2012 image classes, to the `prob` blob. And find the index of element with maximal value in this one. This index correspond to the class of the image. -# Print results - @snippet dnn/samples/caffe_googlenet.cpp Print results + @snippet dnn/caffe_googlenet.cpp Print results For our image we get: > Best class: #812 'space shuttle' > diff --git a/modules/dnn/tutorials/tutorial_dnn_halide.markdown b/modules/dnn/tutorials/tutorial_dnn_halide.markdown index b2a86c82f4..4da0a5ac11 100644 --- a/modules/dnn/tutorials/tutorial_dnn_halide.markdown +++ b/modules/dnn/tutorials/tutorial_dnn_halide.markdown @@ -89,42 +89,42 @@ How to build OpenCV with DNN module you may find in @ref tutorial_dnn_build. ## Sample -@include dnn/samples/squeezenet_halide.cpp +@include dnn/squeezenet_halide.cpp ## Explanation Download Caffe model from SqueezeNet repository: [train_val.prototxt](https://github.com/DeepScale/SqueezeNet/blob/master/SqueezeNet_v1.1/train_val.prototxt) and [squeezenet_v1.1.caffemodel](https://github.com/DeepScale/SqueezeNet/blob/master/SqueezeNet_v1.1/squeezenet_v1.1.caffemodel). Also you need file with names of [ILSVRC2012](http://image-net.org/challenges/LSVRC/2012/browse-synsets) classes: -[synset_words.txt](https://raw.githubusercontent.com/ludv1x/opencv_contrib/master/modules/dnn/samples/synset_words.txt). +[synset_words.txt](https://raw.githubusercontent.com/opencv/opencv/master/modules/samples/data/dnn/synset_words.txt). Put these files into working dir of this program example. -# Read and initialize network using path to .prototxt and .caffemodel files -@snippet dnn/samples/squeezenet_halide.cpp Read and initialize network +@snippet dnn/squeezenet_halide.cpp Read and initialize network -# Check that network was read successfully -@snippet dnn/samples/squeezenet_halide.cpp Check that network was read successfully +@snippet dnn/squeezenet_halide.cpp Check that network was read successfully -# Read input image and convert to the 4-dimensional blob, acceptable by SqueezeNet v1.1 -@snippet dnn/samples/squeezenet_halide.cpp Prepare blob +@snippet dnn/squeezenet_halide.cpp Prepare blob -# Pass the blob to the network -@snippet dnn/samples/squeezenet_halide.cpp Set input blob +@snippet dnn/squeezenet_halide.cpp Set input blob -# Enable Halide backend for layers where it is implemented -@snippet dnn/samples/squeezenet_halide.cpp Enable Halide backend +@snippet dnn/squeezenet_halide.cpp Enable Halide backend -# Make forward pass -@snippet dnn/samples/squeezenet_halide.cpp Make forward pass +@snippet dnn/squeezenet_halide.cpp Make forward pass Remember that the first forward pass after initialization require quite more time that the next ones. It's because of runtime compilation of Halide pipelines at the first invocation. -# Determine the best class -@snippet dnn/samples/squeezenet_halide.cpp Determine the best class +@snippet dnn/squeezenet_halide.cpp Determine the best class -# Print results -@snippet dnn/samples/squeezenet_halide.cpp Print results +@snippet dnn/squeezenet_halide.cpp Print results For our image we get: > Best class: #812 'space shuttle' diff --git a/samples/dnn/squeezenet_halide.cpp b/samples/dnn/squeezenet_halide.cpp index 39f88caae9..b0b553593e 100644 --- a/samples/dnn/squeezenet_halide.cpp +++ b/samples/dnn/squeezenet_halide.cpp @@ -6,7 +6,7 @@ // Third party copyrights are property of their respective owners. // Sample of using Halide backend in OpenCV deep learning module. -// Based on dnn/samples/caffe_googlenet.cpp. +// Based on caffe_googlenet.cpp. #include #include From e03569f3a8d69d23d8e708da938b50b9b2c9ab5f Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 15:12:00 +0300 Subject: [PATCH 06/10] dnn: remove obsolete "build opencv_contrib with dnn module" tutorial --- modules/dnn/tutorials/images/build_1.png | Bin 32126 -> 0 bytes modules/dnn/tutorials/images/build_2.png | Bin 41345 -> 0 bytes modules/dnn/tutorials/images/build_3.png | Bin 46802 -> 0 bytes modules/dnn/tutorials/images/build_4.png | Bin 40770 -> 0 bytes modules/dnn/tutorials/images/build_5.png | Bin 40924 -> 0 bytes .../dnn/tutorials/tutorial_dnn_build.markdown | 68 ------------------ .../tutorials/tutorial_dnn_halide.markdown | 2 - 7 files changed, 70 deletions(-) delete mode 100644 modules/dnn/tutorials/images/build_1.png delete mode 100644 modules/dnn/tutorials/images/build_2.png delete mode 100644 modules/dnn/tutorials/images/build_3.png delete mode 100644 modules/dnn/tutorials/images/build_4.png delete mode 100644 modules/dnn/tutorials/images/build_5.png delete mode 100644 modules/dnn/tutorials/tutorial_dnn_build.markdown diff --git a/modules/dnn/tutorials/images/build_1.png b/modules/dnn/tutorials/images/build_1.png deleted file mode 100644 index 855159e87d741ef9b081ce7d3d8195d694e5b972..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 32126 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 diff --git a/modules/dnn/tutorials/images/build_3.png b/modules/dnn/tutorials/images/build_3.png deleted file mode 100644 index 102d6e339eb3ef7e8c64fdd2908c7b2df3edf778..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 46802 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 diff --git a/modules/dnn/tutorials/images/build_4.png b/modules/dnn/tutorials/images/build_4.png deleted file mode 100644 index 3ad4df8174fb530cd5f52efa725296f6cfb702e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 40770 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¨RBpt0X?to+K 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%0DxBr;7!AVt& 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 **Build Solution** menu or using **F7** short-cut. - --# Now you can build own program by using libraries were built into **opencv_root**/build_opencv/lib. - See the following tutorials to learn how to create a program using OpenCV: - - @ref tutorial_windows_install - - @ref tutorial_linux_gcc_cmake \ No newline at end of file diff --git a/modules/dnn/tutorials/tutorial_dnn_halide.markdown b/modules/dnn/tutorials/tutorial_dnn_halide.markdown index 4da0a5ac11..4bd038d45f 100644 --- a/modules/dnn/tutorials/tutorial_dnn_halide.markdown +++ b/modules/dnn/tutorials/tutorial_dnn_halide.markdown @@ -85,8 +85,6 @@ When you build OpenCV add the following configuration flags: - `HALIDE_ROOT_DIR` - path to Halide build directory -How to build OpenCV with DNN module you may find in @ref tutorial_dnn_build. - ## Sample @include dnn/squeezenet_halide.cpp From ee54bafe6bfd1be76e0d1d07461a40ddae1fede1 Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 15:13:00 +0300 Subject: [PATCH 07/10] dnn: fix dnn python test files --- modules/dnn/test/cityscapes_semsegm_test_enet.py | 6 ++---- modules/dnn/test/imagenet_cls_test_alexnet.py | 12 ++++-------- modules/dnn/test/imagenet_cls_test_googlenet.py | 12 ++++-------- modules/dnn/test/imagenet_cls_test_inception.py | 6 ++---- modules/dnn/test/pascal_semsegm_test_fcn.py | 5 ++--- 5 files changed, 14 insertions(+), 27 deletions(-) diff --git a/modules/dnn/test/cityscapes_semsegm_test_enet.py b/modules/dnn/test/cityscapes_semsegm_test_enet.py index e7e09d4ca4..5f0b4ba625 100644 --- a/modules/dnn/test/cityscapes_semsegm_test_enet.py +++ b/modules/dnn/test/cityscapes_semsegm_test_enet.py @@ -4,13 +4,11 @@ import os import fnmatch import argparse -# sys.path.append('') -sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') try: import cv2 as cv except ImportError: - raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' - 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + raise ImportError('Can\'t find OpenCV Python module. If you\'ve built it from sources without installation, ' + 'configure environemnt variable PYTHONPATH to "opencv_build_dir/lib" directory (with "python3" subdirectory if required)') try: import torch except ImportError: diff --git a/modules/dnn/test/imagenet_cls_test_alexnet.py b/modules/dnn/test/imagenet_cls_test_alexnet.py index de652040af..c136208d87 100644 --- a/modules/dnn/test/imagenet_cls_test_alexnet.py +++ b/modules/dnn/test/imagenet_cls_test_alexnet.py @@ -5,20 +5,16 @@ import os import argparse import time -# sys.path.append('') -sys.path.append('/home/arrybn/git/caffe/python') try: import caffe except ImportError: - raise ImportError('Can\'t find caffe. If you\'ve built it from sources without installation, ' - 'uncomment the line before and insert there path to git/caffe/python dir') -# sys.path.append('') -sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') + raise ImportError('Can\'t find Caffe Python module. If you\'ve built it from sources without installation, ' + 'configure environemnt variable PYTHONPATH to "git/caffe/python" directory') try: import cv2 as cv except ImportError: - raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' - 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + raise ImportError('Can\'t find OpenCV Python module. If you\'ve built it from sources without installation, ' + 'configure environemnt variable PYTHONPATH to "opencv_build_dir/lib" directory (with "python3" subdirectory if required)') class DataFetch(object): diff --git a/modules/dnn/test/imagenet_cls_test_googlenet.py b/modules/dnn/test/imagenet_cls_test_googlenet.py index 210b740ff9..6c7305b022 100644 --- a/modules/dnn/test/imagenet_cls_test_googlenet.py +++ b/modules/dnn/test/imagenet_cls_test_googlenet.py @@ -3,20 +3,16 @@ import sys import os import argparse from imagenet_cls_test_alexnet import MeanChannelsFetch, CaffeModel, DnnCaffeModel, ClsAccEvaluation -# sys.path.append('') -sys.path.append('/home/arrybn/git/caffe/python') try: import caffe except ImportError: - raise ImportError('Can\'t find caffe. If you\'ve built it from sources without installation, ' - 'uncomment the line before and insert there path to git/caffe/python dir') -# sys.path.append('') -sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') + raise ImportError('Can\'t find Caffe Python module. If you\'ve built it from sources without installation, ' + 'configure environemnt variable PYTHONPATH to "git/caffe/python" directory') try: import cv2 as cv except ImportError: - raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' - 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + raise ImportError('Can\'t find OpenCV Python module. If you\'ve built it from sources without installation, ' + 'configure environemnt variable PYTHONPATH to "opencv_build_dir/lib" directory (with "python3" subdirectory if required)') if __name__ == "__main__": parser = argparse.ArgumentParser() diff --git a/modules/dnn/test/imagenet_cls_test_inception.py b/modules/dnn/test/imagenet_cls_test_inception.py index dc4b1ac846..d6f0c55209 100644 --- a/modules/dnn/test/imagenet_cls_test_inception.py +++ b/modules/dnn/test/imagenet_cls_test_inception.py @@ -5,13 +5,11 @@ import argparse import tensorflow as tf from tensorflow.python.platform import gfile from imagenet_cls_test_alexnet import MeanValueFetch, DnnCaffeModel, Framework, ClsAccEvaluation -# sys.path.append('') -sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') try: import cv2 as cv except ImportError: - raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' - 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + raise ImportError('Can\'t find OpenCV Python module. If you\'ve built it from sources without installation, ' + 'configure environemnt variable PYTHONPATH to "opencv_build_dir/lib" directory (with "python3" subdirectory if required)') # If you've got an exception "Cannot load libmkl_avx.so or libmkl_def.so" or similar, try to export next variable # before runnigng the script: diff --git a/modules/dnn/test/pascal_semsegm_test_fcn.py b/modules/dnn/test/pascal_semsegm_test_fcn.py index f7d9cd9dd3..60b061ca37 100644 --- a/modules/dnn/test/pascal_semsegm_test_fcn.py +++ b/modules/dnn/test/pascal_semsegm_test_fcn.py @@ -5,12 +5,11 @@ import argparse import time from imagenet_cls_test_alexnet import CaffeModel, DnnCaffeModel -sys.path.append('/home/arrybn/build/opencv_w_contrib/lib') try: import cv2 as cv except ImportError: - raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, ' - 'uncomment the line before and insert there path to opencv_build_dir/lib dir') + raise ImportError('Can\'t find OpenCV Python module. If you\'ve built it from sources without installation, ' + 'configure environemnt variable PYTHONPATH to "opencv_build_dir/lib" directory (with "python3" subdirectory if required)') def get_metrics(conf_mat): From 623de337e889f9dc275c3c5fef398056fbe9a896 Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 16:22:50 +0300 Subject: [PATCH 08/10] dnn: fix build warnings --- modules/dnn/include/opencv2/dnn/shape_utils.hpp | 8 ++++---- samples/dnn/caffe_googlenet.cpp | 4 ++-- samples/dnn/fcn_semsegm.cpp | 8 ++++---- samples/dnn/squeezenet_halide.cpp | 4 ++-- samples/dnn/ssd_object_detection.cpp | 16 ++++++++-------- samples/dnn/torch_enet.cpp | 12 ++++++------ 6 files changed, 26 insertions(+), 26 deletions(-) diff --git a/modules/dnn/include/opencv2/dnn/shape_utils.hpp b/modules/dnn/include/opencv2/dnn/shape_utils.hpp index d0a16a1b25..c0c8ce47f4 100644 --- a/modules/dnn/include/opencv2/dnn/shape_utils.hpp +++ b/modules/dnn/include/opencv2/dnn/shape_utils.hpp @@ -60,7 +60,7 @@ inline std::ostream &operator<< (std::ostream &s, cv::Range &r) struct _Range : public cv::Range { _Range(const Range &r) : cv::Range(r) {} - _Range(int start, int size = 1) : cv::Range(start, start + size) {} + _Range(int start_, int size_ = 1) : cv::Range(start_, start_ + size_) {} }; static inline Mat slice(const Mat &m, const _Range &r0) @@ -148,13 +148,13 @@ static inline MatShape shape(int a0, int a1=-1, int a2=-1, int a3=-1) static inline int total(const MatShape& shape, int start = -1, int end = -1) { if (start == -1) start = 0; - if (end == -1) end = shape.size(); + if (end == -1) end = (int)shape.size(); if (shape.empty()) return 0; int elems = 1; - CV_Assert(start < shape.size() && end <= shape.size() && + CV_Assert(start < (int)shape.size() && end <= (int)shape.size() && start <= end); for(int i = start; i < end; i++) { @@ -187,7 +187,7 @@ inline int clamp(int ax, int dims) inline int clamp(int ax, const MatShape& shape) { - return clamp(ax, shape.size()); + return clamp(ax, (int)shape.size()); } } diff --git a/samples/dnn/caffe_googlenet.cpp b/samples/dnn/caffe_googlenet.cpp index 59579863f3..f7f325ba70 100644 --- a/samples/dnn/caffe_googlenet.cpp +++ b/samples/dnn/caffe_googlenet.cpp @@ -50,7 +50,7 @@ using namespace cv::dnn; using namespace std; /* Find best class for the blob (i. e. class with maximal probability) */ -void getMaxClass(const Mat &probBlob, int *classId, double *classProb) +static void getMaxClass(const Mat &probBlob, int *classId, double *classProb) { Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix Point classNumber; @@ -59,7 +59,7 @@ void getMaxClass(const Mat &probBlob, int *classId, double *classProb) *classId = classNumber.x; } -std::vector readClassNames(const char *filename = "synset_words.txt") +static std::vector readClassNames(const char *filename = "synset_words.txt") { std::vector classNames; diff --git a/samples/dnn/fcn_semsegm.cpp b/samples/dnn/fcn_semsegm.cpp index 6706050743..062144af3c 100644 --- a/samples/dnn/fcn_semsegm.cpp +++ b/samples/dnn/fcn_semsegm.cpp @@ -33,9 +33,9 @@ static vector readColors(const string &filename = "pascal-classes.txt string name; ss >> name; int temp; cv::Vec3b color; - ss >> temp; color[0] = temp; - ss >> temp; color[1] = temp; - ss >> temp; color[2] = temp; + ss >> temp; color[0] = (uchar)temp; + ss >> temp; color[1] = (uchar)temp; + ss >> temp; color[2] = (uchar)temp; colors.push_back(color); } } @@ -64,7 +64,7 @@ static void colorizeSegmentation(const Mat &score, const vector &colo if (ptrScore[col] > ptrMaxVal[col]) { ptrMaxVal[col] = ptrScore[col]; - ptrMaxCl[col] = ch; + ptrMaxCl[col] = (uchar)ch; } } } diff --git a/samples/dnn/squeezenet_halide.cpp b/samples/dnn/squeezenet_halide.cpp index b0b553593e..ddb01ba187 100644 --- a/samples/dnn/squeezenet_halide.cpp +++ b/samples/dnn/squeezenet_halide.cpp @@ -19,7 +19,7 @@ using namespace cv::dnn; #include /* Find best class for the blob (i. e. class with maximal probability) */ -void getMaxClass(const Mat &probBlob, int *classId, double *classProb) +static void getMaxClass(const Mat &probBlob, int *classId, double *classProb) { Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix Point classNumber; @@ -28,7 +28,7 @@ void getMaxClass(const Mat &probBlob, int *classId, double *classProb) *classId = classNumber.x; } -std::vector readClassNames(const char *filename = "synset_words.txt") +static std::vector readClassNames(const char *filename = "synset_words.txt") { std::vector classNames; diff --git a/samples/dnn/ssd_object_detection.cpp b/samples/dnn/ssd_object_detection.cpp index 016357c4b3..2c564e056f 100644 --- a/samples/dnn/ssd_object_detection.cpp +++ b/samples/dnn/ssd_object_detection.cpp @@ -13,22 +13,22 @@ using namespace std; const size_t width = 300; const size_t height = 300; -Mat getMean(const size_t& imageHeight, const size_t& imageWidth) +static Mat getMean(const size_t& imageHeight, const size_t& imageWidth) { Mat mean; const int meanValues[3] = {104, 117, 123}; vector meanChannels; - for(size_t i = 0; i < 3; i++) + for(int i = 0; i < 3; i++) { - Mat channel(imageHeight, imageWidth, CV_32F, Scalar(meanValues[i])); + Mat channel((int)imageHeight, (int)imageWidth, CV_32F, Scalar(meanValues[i])); meanChannels.push_back(channel); } cv::merge(meanChannels, mean); return mean; } -Mat preprocess(const Mat& frame) +static Mat preprocess(const Mat& frame) { Mat preprocessed; frame.convertTo(preprocessed, CV_32F); @@ -124,7 +124,7 @@ int main(int argc, char** argv) if(confidence > confidenceThreshold) { - size_t objectClass = detectionMat.at(i, 1); + size_t objectClass = (size_t)(detectionMat.at(i, 1)); float xLeftBottom = detectionMat.at(i, 3) * frame.cols; float yLeftBottom = detectionMat.at(i, 4) * frame.rows; @@ -139,9 +139,9 @@ int main(int argc, char** argv) << " " << xRightTop << " " << yRightTop << std::endl; - Rect object(xLeftBottom, yLeftBottom, - xRightTop - xLeftBottom, - yRightTop - yLeftBottom); + Rect object((int)xLeftBottom, (int)yLeftBottom, + (int)(xRightTop - xLeftBottom), + (int)(yRightTop - yLeftBottom)); rectangle(frame, object, Scalar(0, 255, 0)); } diff --git a/samples/dnn/torch_enet.cpp b/samples/dnn/torch_enet.cpp index 1b46e5a058..e27dd16de3 100644 --- a/samples/dnn/torch_enet.cpp +++ b/samples/dnn/torch_enet.cpp @@ -141,7 +141,7 @@ static void colorizeSegmentation(const Mat &score, Mat &segm, Mat &legend, vecto if (ptrScore[col] > ptrMaxVal[col]) { ptrMaxVal[col] = ptrScore[col]; - ptrMaxCl[col] = ch; + ptrMaxCl[col] = (uchar)ch; } } } @@ -161,8 +161,8 @@ static void colorizeSegmentation(const Mat &score, Mat &segm, Mat &legend, vecto if (classNames.size() == colors.size()) { int blockHeight = 30; - legend.create(blockHeight*classNames.size(), 200, CV_8UC3); - for(int i = 0; i < classNames.size(); i++) + legend.create(blockHeight*(int)classNames.size(), 200, CV_8UC3); + for(int i = 0; i < (int)classNames.size(); i++) { cv::Mat block = legend.rowRange(i*blockHeight, (i+1)*blockHeight); block = colors[i]; @@ -194,9 +194,9 @@ static vector readColors(const String &filename, vector& classNam string name; ss >> name; int temp; cv::Vec3b color; - ss >> temp; color[0] = temp; - ss >> temp; color[1] = temp; - ss >> temp; color[2] = temp; + ss >> temp; color[0] = (uchar)temp; + ss >> temp; color[1] = (uchar)temp; + ss >> temp; color[2] = (uchar)temp; classNames.push_back(name); colors.push_back(color); } From 93091ba20388660801cc403027c1c591648906d4 Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 18:52:09 +0300 Subject: [PATCH 09/10] dnn: AVX2 fix invalid unaligned read --- modules/dnn/src/layers/layers_common.avx2.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/modules/dnn/src/layers/layers_common.avx2.cpp b/modules/dnn/src/layers/layers_common.avx2.cpp index 8b08ac0230..5efa834579 100644 --- a/modules/dnn/src/layers/layers_common.avx2.cpp +++ b/modules/dnn/src/layers/layers_common.avx2.cpp @@ -50,6 +50,8 @@ namespace cv { namespace dnn { +#define _mm256_load_ps _mm256_loadu_ps // "weights" in fastConv_avx2 is not always aligned to 32 bytes + void fastConv_avx2( const float* weights, size_t wstep, const float* bias, const float* rowbuf, float* output, const int* outShape, int blockSize, int vecsize, int vecsize_aligned, From 986d27e49c839fcdf622b8e424ae3122e018af3a Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 26 Jun 2017 19:27:05 +0300 Subject: [PATCH 10/10] dnn: fix failed Torch tests "Torch invalid argument 2: position must be smaller than LLONG_MAX" These conditions are always true for "long position" argument. --- modules/dnn/src/torch/THDiskFile.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/modules/dnn/src/torch/THDiskFile.cpp b/modules/dnn/src/torch/THDiskFile.cpp index c56b0f4899..25346a8711 100644 --- a/modules/dnn/src/torch/THDiskFile.cpp +++ b/modules/dnn/src/torch/THDiskFile.cpp @@ -175,13 +175,10 @@ static void THDiskFile_seek(THFile *self, long position) THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); #if defined(_WIN64) - THArgCheck(position <= (_int64)INT64_MAX, 2, "position must be smaller than INT64_MAX"); if(_fseeki64(dfself->handle, (__int64)position, SEEK_SET) < 0) #elif defined(_WIN32) - THArgCheck(position <= (long)LONG_MAX, 2, "position must be smaller than LONG_MAX"); if(fseek(dfself->handle, (long)position, SEEK_SET) < 0) #else - THArgCheck(position <= (long)LLONG_MAX, 2, "position must be smaller than LLONG_MAX"); if(fseeko(dfself->handle, (off_t)position, SEEK_SET) < 0) #endif {