diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt new file mode 100644 index 0000000..a226414 --- /dev/null +++ b/python/CMakeLists.txt @@ -0,0 +1,34 @@ +if(NOT HAVE_PYTHON) + message(STATUS "Python interface is disabled or not all required dependencies found. Building without it...") + return() +endif() + +include_directories(${PYTHON_INCLUDE_DIRS} ${NUMPY_INCLUDE_DIR} ${Boost_INCLUDE_DIRS}) +file(GLOB_RECURSE python_srcs ${PROJECT_SOURCE_DIR}/python/*.cpp) + +add_library(pycaffe SHARED ${python_srcs}) +target_link_libraries(pycaffe ${Caffe_LINK} ${PYTHON_LIBRARIES} ${Boost_LIBRARIES}) +set_target_properties(pycaffe PROPERTIES PREFIX "" OUTPUT_NAME "_caffe") +caffe_default_properties(pycaffe) + +if(UNIX OR APPLE) + set(__linkname "${PROJECT_SOURCE_DIR}/python/caffe/_caffe.so") + add_custom_command(TARGET pycaffe POST_BUILD + COMMAND ln -sf $ "${__linkname}" + COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/python/caffe/proto + COMMAND touch ${PROJECT_SOURCE_DIR}/python/caffe/proto/__init__.py + COMMAND cp ${proto_gen_folder}/*.py ${PROJECT_SOURCE_DIR}/python/caffe/proto/ + COMMENT "Creating symlink ${__linkname} -> ${PROJECT_BINARY_DIR}/lib/_caffe${Caffe_POSTFIX}.so") +endif() + +# ---[ Install +file(GLOB files1 *.py requirements.txt) +install(FILES ${files1} DESTINATION python) + +file(GLOB files2 caffe/*.py) +install(FILES ${files2} DESTINATION python/caffe) +install(TARGETS pycaffe DESTINATION python/caffe) +install(DIRECTORY caffe/imagenet caffe/proto caffe/test DESTINATION python/caffe) + + + diff --git a/python/caffe/__init__.py b/python/caffe/__init__.py new file mode 100644 index 0000000..e2881b8 --- /dev/null +++ b/python/caffe/__init__.py @@ -0,0 +1,8 @@ +from .pycaffe import Net, SGDSolver, NesterovSolver, AdaGradSolver, RMSPropSolver, AdaDeltaSolver, AdamSolver +from ._caffe import set_mode_cpu, set_mode_gpu, set_device, Layer, get_solver, layer_type_list +from ._caffe import __version__ +from .proto.caffe_pb2 import TRAIN, TEST +from .classifier import Classifier +from .detector import Detector +from . import io +from .net_spec import layers, params, NetSpec, to_proto diff --git a/python/caffe/__init__.pyc b/python/caffe/__init__.pyc new file mode 100644 index 0000000..a2d8da9 Binary files /dev/null and b/python/caffe/__init__.pyc differ diff --git a/python/caffe/__pycache__/io.cpython-34.pyc b/python/caffe/__pycache__/io.cpython-34.pyc new file mode 100644 index 0000000..b4b760d Binary files /dev/null and b/python/caffe/__pycache__/io.cpython-34.pyc differ diff --git a/python/caffe/_caffe.cpp b/python/caffe/_caffe.cpp new file mode 100644 index 0000000..334088e --- /dev/null +++ b/python/caffe/_caffe.cpp @@ -0,0 +1,395 @@ +#include // NOLINT(build/include_alpha) + +// Produce deprecation warnings (needs to come before arrayobject.h inclusion). +#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION + +#include +#include +#include +#include +#include + +// these need to be included after boost on OS X +#include // NOLINT(build/include_order) +#include // NOLINT(build/include_order) +#include // NOLINT + +#include "caffe/caffe.hpp" +#include "caffe/layers/memory_data_layer.hpp" +#include "caffe/layers/python_layer.hpp" +#include "caffe/sgd_solvers.hpp" + +// Temporary solution for numpy < 1.7 versions: old macro, no promises. +// You're strongly advised to upgrade to >= 1.7. +#ifndef NPY_ARRAY_C_CONTIGUOUS +#define NPY_ARRAY_C_CONTIGUOUS NPY_C_CONTIGUOUS +#define PyArray_SetBaseObject(arr, x) (PyArray_BASE(arr) = (x)) +#endif + +/* Fix to avoid registration warnings in pycaffe (#3960) */ +#define BP_REGISTER_SHARED_PTR_TO_PYTHON(PTR) do { \ + const boost::python::type_info info = \ + boost::python::type_id >(); \ + const boost::python::converter::registration* reg = \ + boost::python::converter::registry::query(info); \ + if (reg == NULL) { \ + bp::register_ptr_to_python >(); \ + } else if ((*reg).m_to_python == NULL) { \ + bp::register_ptr_to_python >(); \ + } \ +} while (0) + +namespace bp = boost::python; + +namespace caffe { + +// For Python, for now, we'll just always use float as the type. +typedef float Dtype; +const int NPY_DTYPE = NPY_FLOAT32; + +// Selecting mode. +void set_mode_cpu() { Caffe::set_mode(Caffe::CPU); } +void set_mode_gpu() { Caffe::set_mode(Caffe::GPU); } + +// For convenience, check that input files can be opened, and raise an +// exception that boost will send to Python if not (caffe could still crash +// later if the input files are disturbed before they are actually used, but +// this saves frustration in most cases). +static void CheckFile(const string& filename) { + std::ifstream f(filename.c_str()); + if (!f.good()) { + f.close(); + throw std::runtime_error("Could not open file " + filename); + } + f.close(); +} + +void CheckContiguousArray(PyArrayObject* arr, string name, + int channels, int height, int width) { + if (!(PyArray_FLAGS(arr) & NPY_ARRAY_C_CONTIGUOUS)) { + throw std::runtime_error(name + " must be C contiguous"); + } + if (PyArray_NDIM(arr) != 4) { + throw std::runtime_error(name + " must be 4-d"); + } + if (PyArray_TYPE(arr) != NPY_FLOAT32) { + throw std::runtime_error(name + " must be float32"); + } + if (PyArray_DIMS(arr)[1] != channels) { + throw std::runtime_error(name + " has wrong number of channels"); + } + if (PyArray_DIMS(arr)[2] != height) { + throw std::runtime_error(name + " has wrong height"); + } + if (PyArray_DIMS(arr)[3] != width) { + throw std::runtime_error(name + " has wrong width"); + } +} + +// Net constructor for passing phase as int +shared_ptr > Net_Init( + string param_file, int phase) { + CheckFile(param_file); + + shared_ptr > net(new Net(param_file, + static_cast(phase))); + return net; +} + +// Net construct-and-load convenience constructor +shared_ptr > Net_Init_Load( + string param_file, string pretrained_param_file, int phase) { + CheckFile(param_file); + CheckFile(pretrained_param_file); + + shared_ptr > net(new Net(param_file, + static_cast(phase))); + net->CopyTrainedLayersFrom(pretrained_param_file); + return net; +} + +void Net_Save(const Net& net, string filename) { + NetParameter net_param; + net.ToProto(&net_param, false); + WriteProtoToBinaryFile(net_param, filename.c_str()); +} + +void Net_SaveHDF5(const Net& net, string filename) { + net.ToHDF5(filename); +} + +void Net_LoadHDF5(Net* net, string filename) { + net->CopyTrainedLayersFromHDF5(filename.c_str()); +} + +void Net_SetInputArrays(Net* net, bp::object data_obj, + bp::object labels_obj) { + // check that this network has an input MemoryDataLayer + shared_ptr > md_layer = + boost::dynamic_pointer_cast >(net->layers()[0]); + if (!md_layer) { + throw std::runtime_error("set_input_arrays may only be called if the" + " first layer is a MemoryDataLayer"); + } + + // check that we were passed appropriately-sized contiguous memory + PyArrayObject* data_arr = + reinterpret_cast(data_obj.ptr()); + PyArrayObject* labels_arr = + reinterpret_cast(labels_obj.ptr()); + CheckContiguousArray(data_arr, "data array", md_layer->channels(), + md_layer->height(), md_layer->width()); + CheckContiguousArray(labels_arr, "labels array", 1, 1, 1); + if (PyArray_DIMS(data_arr)[0] != PyArray_DIMS(labels_arr)[0]) { + throw std::runtime_error("data and labels must have the same first" + " dimension"); + } + if (PyArray_DIMS(data_arr)[0] % md_layer->batch_size() != 0) { + throw std::runtime_error("first dimensions of input arrays must be a" + " multiple of batch size"); + } + + md_layer->Reset(static_cast(PyArray_DATA(data_arr)), + static_cast(PyArray_DATA(labels_arr)), + PyArray_DIMS(data_arr)[0]); +} + +Solver* GetSolverFromFile(const string& filename) { + SolverParameter param; + ReadSolverParamsFromTextFileOrDie(filename, ¶m); + return SolverRegistry::CreateSolver(param); +} + +struct NdarrayConverterGenerator { + template struct apply; +}; + +template <> +struct NdarrayConverterGenerator::apply { + struct type { + PyObject* operator() (Dtype* data) const { + // Just store the data pointer, and add the shape information in postcall. + return PyArray_SimpleNewFromData(0, NULL, NPY_DTYPE, data); + } + const PyTypeObject* get_pytype() { + return &PyArray_Type; + } + }; +}; + +struct NdarrayCallPolicies : public bp::default_call_policies { + typedef NdarrayConverterGenerator result_converter; + PyObject* postcall(PyObject* pyargs, PyObject* result) { + bp::object pyblob = bp::extract(pyargs)()[0]; + shared_ptr > blob = + bp::extract > >(pyblob); + // Free the temporary pointer-holding array, and construct a new one with + // the shape information from the blob. + void* data = PyArray_DATA(reinterpret_cast(result)); + Py_DECREF(result); + const int num_axes = blob->num_axes(); + vector dims(blob->shape().begin(), blob->shape().end()); + PyObject *arr_obj = PyArray_SimpleNewFromData(num_axes, dims.data(), + NPY_FLOAT32, data); + // SetBaseObject steals a ref, so we need to INCREF. + Py_INCREF(pyblob.ptr()); + PyArray_SetBaseObject(reinterpret_cast(arr_obj), + pyblob.ptr()); + return arr_obj; + } +}; + +bp::object Blob_Reshape(bp::tuple args, bp::dict kwargs) { + if (bp::len(kwargs) > 0) { + throw std::runtime_error("Blob.reshape takes no kwargs"); + } + Blob* self = bp::extract*>(args[0]); + vector shape(bp::len(args) - 1); + for (int i = 1; i < bp::len(args); ++i) { + shape[i - 1] = bp::extract(args[i]); + } + self->Reshape(shape); + // We need to explicitly return None to use bp::raw_function. + return bp::object(); +} + +bp::object BlobVec_add_blob(bp::tuple args, bp::dict kwargs) { + if (bp::len(kwargs) > 0) { + throw std::runtime_error("BlobVec.add_blob takes no kwargs"); + } + typedef vector > > BlobVec; + BlobVec* self = bp::extract(args[0]); + vector shape(bp::len(args) - 1); + for (int i = 1; i < bp::len(args); ++i) { + shape[i - 1] = bp::extract(args[i]); + } + self->push_back(shared_ptr >(new Blob(shape))); + // We need to explicitly return None to use bp::raw_function. + return bp::object(); +} + +template +class PythonCallback: public Solver::Callback { + protected: + bp::object on_start_, on_gradients_ready_; + + public: + PythonCallback(bp::object on_start, bp::object on_gradients_ready) + : on_start_(on_start), on_gradients_ready_(on_gradients_ready) { } + virtual void on_gradients_ready() { + on_gradients_ready_(); + } + virtual void on_start() { + on_start_(); + } +}; +template +void Solver_add_callback(Solver * solver, bp::object on_start, + bp::object on_gradients_ready) { + solver->add_callback(new PythonCallback(on_start, on_gradients_ready)); +} + +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(SolveOverloads, Solve, 0, 1); + +BOOST_PYTHON_MODULE(_caffe) { + // below, we prepend an underscore to methods that will be replaced + // in Python + + bp::scope().attr("__version__") = AS_STRING(CAFFE_VERSION); + + // Caffe utility functions + bp::def("set_mode_cpu", &set_mode_cpu); + bp::def("set_mode_gpu", &set_mode_gpu); + bp::def("set_device", &Caffe::SetDevice); + + bp::def("layer_type_list", &LayerRegistry::LayerTypeList); + + bp::class_, shared_ptr >, boost::noncopyable >("Net", + bp::no_init) + .def("__init__", bp::make_constructor(&Net_Init)) + .def("__init__", bp::make_constructor(&Net_Init_Load)) + .def("_forward", &Net::ForwardFromTo) + .def("_backward", &Net::BackwardFromTo) + .def("reshape", &Net::Reshape) + // The cast is to select a particular overload. + .def("copy_from", static_cast::*)(const string)>( + &Net::CopyTrainedLayersFrom)) + .def("share_with", &Net::ShareTrainedLayersWith) + .add_property("_blob_loss_weights", bp::make_function( + &Net::blob_loss_weights, bp::return_internal_reference<>())) + .def("_bottom_ids", bp::make_function(&Net::bottom_ids, + bp::return_value_policy())) + .def("_top_ids", bp::make_function(&Net::top_ids, + bp::return_value_policy())) + .add_property("_blobs", bp::make_function(&Net::blobs, + bp::return_internal_reference<>())) + .add_property("layers", bp::make_function(&Net::layers, + bp::return_internal_reference<>())) + .add_property("_blob_names", bp::make_function(&Net::blob_names, + bp::return_value_policy())) + .add_property("_layer_names", bp::make_function(&Net::layer_names, + bp::return_value_policy())) + .add_property("_inputs", bp::make_function(&Net::input_blob_indices, + bp::return_value_policy())) + .add_property("_outputs", + bp::make_function(&Net::output_blob_indices, + bp::return_value_policy())) + .def("_set_input_arrays", &Net_SetInputArrays, + bp::with_custodian_and_ward<1, 2, bp::with_custodian_and_ward<1, 3> >()) + .def("save", &Net_Save) + .def("save_hdf5", &Net_SaveHDF5) + .def("load_hdf5", &Net_LoadHDF5); + BP_REGISTER_SHARED_PTR_TO_PYTHON(Net); + + bp::class_, shared_ptr >, boost::noncopyable>( + "Blob", bp::no_init) + .add_property("shape", + bp::make_function( + static_cast& (Blob::*)() const>( + &Blob::shape), + bp::return_value_policy())) + .add_property("num", &Blob::num) + .add_property("channels", &Blob::channels) + .add_property("height", &Blob::height) + .add_property("width", &Blob::width) + .add_property("count", static_cast::*)() const>( + &Blob::count)) + .def("reshape", bp::raw_function(&Blob_Reshape)) + .add_property("data", bp::make_function(&Blob::mutable_cpu_data, + NdarrayCallPolicies())) + .add_property("diff", bp::make_function(&Blob::mutable_cpu_diff, + NdarrayCallPolicies())); + BP_REGISTER_SHARED_PTR_TO_PYTHON(Blob); + + bp::class_, shared_ptr >, + boost::noncopyable>("Layer", bp::init()) + .add_property("blobs", bp::make_function(&Layer::blobs, + bp::return_internal_reference<>())) + .def("setup", &Layer::LayerSetUp) + .def("reshape", &Layer::Reshape) + .add_property("type", bp::make_function(&Layer::type)); + BP_REGISTER_SHARED_PTR_TO_PYTHON(Layer); + + bp::class_("LayerParameter", bp::no_init); + + bp::class_, shared_ptr >, boost::noncopyable>( + "Solver", bp::no_init) + .add_property("net", &Solver::net) + .add_property("test_nets", bp::make_function(&Solver::test_nets, + bp::return_internal_reference<>())) + .add_property("iter", &Solver::iter) + .def("add_callback", &Solver_add_callback) + .def("solve", static_cast::*)(const char*)>( + &Solver::Solve), SolveOverloads()) + .def("step", &Solver::Step) + .def("restore", &Solver::Restore) + .def("snapshot", &Solver::Snapshot); + BP_REGISTER_SHARED_PTR_TO_PYTHON(Solver); + + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "SGDSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "NesterovSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "AdaGradSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "RMSPropSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "AdaDeltaSolver", bp::init()); + bp::class_, bp::bases >, + shared_ptr >, boost::noncopyable>( + "AdamSolver", bp::init()); + + bp::def("get_solver", &GetSolverFromFile, + bp::return_value_policy()); + + // vector wrappers for all the vector types we use + bp::class_ > > >("BlobVec") + .def(bp::vector_indexing_suite > >, true>()) + .def("add_blob", bp::raw_function(&BlobVec_add_blob)); + bp::class_*> >("RawBlobVec") + .def(bp::vector_indexing_suite*>, true>()); + bp::class_ > > >("LayerVec") + .def(bp::vector_indexing_suite > >, true>()); + bp::class_ >("StringVec") + .def(bp::vector_indexing_suite >()); + bp::class_ >("IntVec") + .def(bp::vector_indexing_suite >()); + bp::class_ >("DtypeVec") + .def(bp::vector_indexing_suite >()); + bp::class_ > > >("NetVec") + .def(bp::vector_indexing_suite > >, true>()); + bp::class_ >("BoolVec") + .def(bp::vector_indexing_suite >()); + + // boost python expects a void (missing) return value, while import_array + // returns NULL for python3. import_array1() forces a void return value. + import_array1(); +} + +} // namespace caffe diff --git a/python/caffe/_caffe.so b/python/caffe/_caffe.so new file mode 100644 index 0000000..8bed096 Binary files /dev/null and b/python/caffe/_caffe.so differ diff --git a/python/caffe/classifier.py b/python/caffe/classifier.py new file mode 100644 index 0000000..ea29fed --- /dev/null +++ b/python/caffe/classifier.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python +""" +Classifier is an image classifier specialization of Net. +""" + +import numpy as np + +import caffe + + +class Classifier(caffe.Net): + """ + Classifier extends Net for image class prediction + by scaling, center cropping, or oversampling. + + Parameters + ---------- + image_dims : dimensions to scale input for cropping/sampling. + Default is to scale to net input size for whole-image crop. + mean, input_scale, raw_scale, channel_swap: params for + preprocessing options. + """ + def __init__(self, model_file, pretrained_file, image_dims=None, + mean=None, input_scale=None, raw_scale=None, + channel_swap=None): + caffe.Net.__init__(self, model_file, pretrained_file, caffe.TEST) + + # configure pre-processing + in_ = self.inputs[0] + self.transformer = caffe.io.Transformer( + {in_: self.blobs[in_].data.shape}) + self.transformer.set_transpose(in_, (2, 0, 1)) + if mean is not None: + self.transformer.set_mean(in_, mean) + if input_scale is not None: + self.transformer.set_input_scale(in_, input_scale) + if raw_scale is not None: + self.transformer.set_raw_scale(in_, raw_scale) + if channel_swap is not None: + self.transformer.set_channel_swap(in_, channel_swap) + + self.crop_dims = np.array(self.blobs[in_].data.shape[2:]) + if not image_dims: + image_dims = self.crop_dims + self.image_dims = image_dims + + def predict(self, inputs, oversample=True): + """ + Predict classification probabilities of inputs. + + Parameters + ---------- + inputs : iterable of (H x W x K) input ndarrays. + oversample : boolean + average predictions across center, corners, and mirrors + when True (default). Center-only prediction when False. + + Returns + ------- + predictions: (N x C) ndarray of class probabilities for N images and C + classes. + """ + # Scale to standardize input dimensions. + input_ = np.zeros((len(inputs), + self.image_dims[0], + self.image_dims[1], + inputs[0].shape[2]), + dtype=np.float32) + for ix, in_ in enumerate(inputs): + input_[ix] = caffe.io.resize_image(in_, self.image_dims) + + if oversample: + # Generate center, corner, and mirrored crops. + input_ = caffe.io.oversample(input_, self.crop_dims) + else: + # Take center crop. + center = np.array(self.image_dims) / 2.0 + crop = np.tile(center, (1, 2))[0] + np.concatenate([ + -self.crop_dims / 2.0, + self.crop_dims / 2.0 + ]) + crop = crop.astype(int) + input_ = input_[:, crop[0]:crop[2], crop[1]:crop[3], :] + + # Classify + caffe_in = np.zeros(np.array(input_.shape)[[0, 3, 1, 2]], + dtype=np.float32) + for ix, in_ in enumerate(input_): + caffe_in[ix] = self.transformer.preprocess(self.inputs[0], in_) + out = self.forward_all(**{self.inputs[0]: caffe_in}) + predictions = out[self.outputs[0]] + + # For oversampling, average predictions across crops. + if oversample: + predictions = predictions.reshape((len(predictions) / 10, 10, -1)) + predictions = predictions.mean(1) + + return predictions diff --git a/python/caffe/classifier.pyc b/python/caffe/classifier.pyc new file mode 100644 index 0000000..b4cc086 Binary files /dev/null and b/python/caffe/classifier.pyc differ diff --git a/python/caffe/coord_map.py b/python/caffe/coord_map.py new file mode 100644 index 0000000..a3413cf --- /dev/null +++ b/python/caffe/coord_map.py @@ -0,0 +1,185 @@ +""" +Determine spatial relationships between layers to relate their coordinates. +Coordinates are mapped from input-to-output (forward), but can +be mapped output-to-input (backward) by the inverse mapping too. +This helps crop and align feature maps among other uses. +""" + +from __future__ import division +import numpy as np +from caffe import layers as L + +PASS_THROUGH_LAYERS = ['AbsVal', 'BatchNorm', 'Bias', 'BNLL', 'Dropout', + 'Eltwise', 'ELU', 'Log', 'LRN', 'Exp', 'MVN', 'Power', + 'ReLU', 'PReLU', 'Scale', 'Sigmoid', 'Split', 'TanH', + 'Threshold'] + + +def conv_params(fn): + """ + Extract the spatial parameters that determine the coordinate mapping: + kernel size, stride, padding, and dilation. + + Implementation detail: Convolution, Deconvolution, and Im2col layers + define these in the convolution_param message, while Pooling has its + own fields in pooling_param. This method deals with these details to + extract canonical parameters. + """ + params = fn.params.get('convolution_param', fn.params) + axis = params.get('axis', 1) + ks = np.array(params['kernel_size'], ndmin=1) + dilation = np.array(params.get('dilation', 1), ndmin=1) + assert len({'pad_h', 'pad_w', 'kernel_h', 'kernel_w', 'stride_h', + 'stride_w'} & set(fn.params)) == 0, \ + 'cropping does not support legacy _h/_w params' + return (axis, np.array(params.get('stride', 1), ndmin=1), + (ks - 1) * dilation + 1, + np.array(params.get('pad', 0), ndmin=1)) + + +def crop_params(fn): + """ + Extract the crop layer parameters with defaults. + """ + params = fn.params.get('crop_param', fn.params) + axis = params.get('axis', 2) # default to spatial crop for N, C, H, W + offset = np.array(params.get('offset', 0), ndmin=1) + return (axis, offset) + + +class UndefinedMapException(Exception): + """ + Exception raised for layers that do not have a defined coordinate mapping. + """ + pass + + +def coord_map(fn): + """ + Define the coordinate mapping by its + - axis + - scale: output coord[i * scale] <- input_coord[i] + - shift: output coord[i] <- output_coord[i + shift] + s.t. the identity mapping, as for pointwise layers like ReLu, is defined by + (None, 1, 0) since it is independent of axis and does not transform coords. + """ + if fn.type_name in ['Convolution', 'Pooling', 'Im2col']: + axis, stride, ks, pad = conv_params(fn) + return axis, 1 / stride, (pad - (ks - 1) / 2) / stride + elif fn.type_name == 'Deconvolution': + axis, stride, ks, pad = conv_params(fn) + return axis, stride, (ks - 1) / 2 - pad + elif fn.type_name in PASS_THROUGH_LAYERS: + return None, 1, 0 + elif fn.type_name == 'Crop': + axis, offset = crop_params(fn) + axis -= 1 # -1 for last non-coordinate dim. + return axis, 1, - offset + else: + raise UndefinedMapException + + +class AxisMismatchException(Exception): + """ + Exception raised for mappings with incompatible axes. + """ + pass + + +def compose(base_map, next_map): + """ + Compose a base coord map with scale a1, shift b1 with a further coord map + with scale a2, shift b2. The scales multiply and the further shift, b2, + is scaled by base coord scale a1. + """ + ax1, a1, b1 = base_map + ax2, a2, b2 = next_map + if ax1 is None: + ax = ax2 + elif ax2 is None or ax1 == ax2: + ax = ax1 + else: + raise AxisMismatchException + return ax, a1 * a2, a1 * b2 + b1 + + +def inverse(coord_map): + """ + Invert a coord map by de-scaling and un-shifting; + this gives the backward mapping for the gradient. + """ + ax, a, b = coord_map + return ax, 1 / a, -b / a + + +def coord_map_from_to(top_from, top_to): + """ + Determine the coordinate mapping betweeen a top (from) and a top (to). + Walk the graph to find a common ancestor while composing the coord maps for + from and to until they meet. As a last step the from map is inverted. + """ + # We need to find a common ancestor of top_from and top_to. + # We'll assume that all ancestors are equivalent here (otherwise the graph + # is an inconsistent state (which we could improve this to check for)). + # For now use a brute-force algorithm. + + def collect_bottoms(top): + """ + Collect the bottoms to walk for the coordinate mapping. + The general rule is that all the bottoms of a layer can be mapped, as + most layers have the same coordinate mapping for each bottom. + Crop layer is a notable exception. Only the first/cropped bottom is + mappable; the second/dimensions bottom is excluded from the walk. + """ + bottoms = top.fn.inputs + if top.fn.type_name == 'Crop': + bottoms = bottoms[:1] + return bottoms + + # walk back from top_from, keeping the coord map as we go + from_maps = {top_from: (None, 1, 0)} + frontier = {top_from} + while frontier: + top = frontier.pop() + try: + bottoms = collect_bottoms(top) + for bottom in bottoms: + from_maps[bottom] = compose(from_maps[top], coord_map(top.fn)) + frontier.add(bottom) + except UndefinedMapException: + pass + + # now walk back from top_to until we hit a common blob + to_maps = {top_to: (None, 1, 0)} + frontier = {top_to} + while frontier: + top = frontier.pop() + if top in from_maps: + return compose(to_maps[top], inverse(from_maps[top])) + try: + bottoms = collect_bottoms(top) + for bottom in bottoms: + to_maps[bottom] = compose(to_maps[top], coord_map(top.fn)) + frontier.add(bottom) + except UndefinedMapException: + continue + + # if we got here, we did not find a blob in common + raise RuntimeError('Could not compute map between tops; are they ' + 'connected by spatial layers?') + + +def crop(top_from, top_to): + """ + Define a Crop layer to crop a top (from) to another top (to) by + determining the coordinate mapping between the two and net spec'ing + the axis and shift parameters of the crop. + """ + ax, a, b = coord_map_from_to(top_from, top_to) + assert (a == 1).all(), 'scale mismatch on crop (a = {})'.format(a) + assert (b <= 0).all(), 'cannot crop negative offset (b = {})'.format(b) + assert (np.round(b) == b).all(), 'cannot crop noninteger offset ' \ + '(b = {})'.format(b) + return L.Crop(top_from, top_to, + crop_param=dict(axis=ax + 1, # +1 for first cropping dim. + offset=list(-np.round(b).astype(int)))) diff --git a/python/caffe/detector.py b/python/caffe/detector.py new file mode 100644 index 0000000..75cd3b1 --- /dev/null +++ b/python/caffe/detector.py @@ -0,0 +1,216 @@ +#!/usr/bin/env python +""" +Do windowed detection by classifying a number of images/crops at once, +optionally using the selective search window proposal method. + +This implementation follows ideas in + Ross Girshick, Jeff Donahue, Trevor Darrell, Jitendra Malik. + Rich feature hierarchies for accurate object detection and semantic + segmentation. + http://arxiv.org/abs/1311.2524 + +The selective_search_ijcv_with_python code required for the selective search +proposal mode is available at + https://github.com/sergeyk/selective_search_ijcv_with_python +""" +import numpy as np +import os + +import caffe + + +class Detector(caffe.Net): + """ + Detector extends Net for windowed detection by a list of crops or + selective search proposals. + + Parameters + ---------- + mean, input_scale, raw_scale, channel_swap : params for preprocessing + options. + context_pad : amount of surrounding context to take s.t. a `context_pad` + sized border of pixels in the network input image is context, as in + R-CNN feature extraction. + """ + def __init__(self, model_file, pretrained_file, mean=None, + input_scale=None, raw_scale=None, channel_swap=None, + context_pad=None): + caffe.Net.__init__(self, model_file, pretrained_file, caffe.TEST) + + # configure pre-processing + in_ = self.inputs[0] + self.transformer = caffe.io.Transformer( + {in_: self.blobs[in_].data.shape}) + self.transformer.set_transpose(in_, (2, 0, 1)) + if mean is not None: + self.transformer.set_mean(in_, mean) + if input_scale is not None: + self.transformer.set_input_scale(in_, input_scale) + if raw_scale is not None: + self.transformer.set_raw_scale(in_, raw_scale) + if channel_swap is not None: + self.transformer.set_channel_swap(in_, channel_swap) + + self.configure_crop(context_pad) + + def detect_windows(self, images_windows): + """ + Do windowed detection over given images and windows. Windows are + extracted then warped to the input dimensions of the net. + + Parameters + ---------- + images_windows: (image filename, window list) iterable. + context_crop: size of context border to crop in pixels. + + Returns + ------- + detections: list of {filename: image filename, window: crop coordinates, + predictions: prediction vector} dicts. + """ + # Extract windows. + window_inputs = [] + for image_fname, windows in images_windows: + image = caffe.io.load_image(image_fname).astype(np.float32) + for window in windows: + window_inputs.append(self.crop(image, window)) + + # Run through the net (warping windows to input dimensions). + in_ = self.inputs[0] + caffe_in = np.zeros((len(window_inputs), window_inputs[0].shape[2]) + + self.blobs[in_].data.shape[2:], + dtype=np.float32) + for ix, window_in in enumerate(window_inputs): + caffe_in[ix] = self.transformer.preprocess(in_, window_in) + out = self.forward_all(**{in_: caffe_in}) + predictions = out[self.outputs[0]].squeeze(axis=(2, 3)) + + # Package predictions with images and windows. + detections = [] + ix = 0 + for image_fname, windows in images_windows: + for window in windows: + detections.append({ + 'window': window, + 'prediction': predictions[ix], + 'filename': image_fname + }) + ix += 1 + return detections + + def detect_selective_search(self, image_fnames): + """ + Do windowed detection over Selective Search proposals by extracting + the crop and warping to the input dimensions of the net. + + Parameters + ---------- + image_fnames: list + + Returns + ------- + detections: list of {filename: image filename, window: crop coordinates, + predictions: prediction vector} dicts. + """ + import selective_search_ijcv_with_python as selective_search + # Make absolute paths so MATLAB can find the files. + image_fnames = [os.path.abspath(f) for f in image_fnames] + windows_list = selective_search.get_windows( + image_fnames, + cmd='selective_search_rcnn' + ) + # Run windowed detection on the selective search list. + return self.detect_windows(zip(image_fnames, windows_list)) + + def crop(self, im, window): + """ + Crop a window from the image for detection. Include surrounding context + according to the `context_pad` configuration. + + Parameters + ---------- + im: H x W x K image ndarray to crop. + window: bounding box coordinates as ymin, xmin, ymax, xmax. + + Returns + ------- + crop: cropped window. + """ + # Crop window from the image. + crop = im[window[0]:window[2], window[1]:window[3]] + + if self.context_pad: + box = window.copy() + crop_size = self.blobs[self.inputs[0]].width # assumes square + scale = crop_size / (1. * crop_size - self.context_pad * 2) + # Crop a box + surrounding context. + half_h = (box[2] - box[0] + 1) / 2. + half_w = (box[3] - box[1] + 1) / 2. + center = (box[0] + half_h, box[1] + half_w) + scaled_dims = scale * np.array((-half_h, -half_w, half_h, half_w)) + box = np.round(np.tile(center, 2) + scaled_dims) + full_h = box[2] - box[0] + 1 + full_w = box[3] - box[1] + 1 + scale_h = crop_size / full_h + scale_w = crop_size / full_w + pad_y = round(max(0, -box[0]) * scale_h) # amount out-of-bounds + pad_x = round(max(0, -box[1]) * scale_w) + + # Clip box to image dimensions. + im_h, im_w = im.shape[:2] + box = np.clip(box, 0., [im_h, im_w, im_h, im_w]) + clip_h = box[2] - box[0] + 1 + clip_w = box[3] - box[1] + 1 + assert(clip_h > 0 and clip_w > 0) + crop_h = round(clip_h * scale_h) + crop_w = round(clip_w * scale_w) + if pad_y + crop_h > crop_size: + crop_h = crop_size - pad_y + if pad_x + crop_w > crop_size: + crop_w = crop_size - pad_x + + # collect with context padding and place in input + # with mean padding + context_crop = im[box[0]:box[2], box[1]:box[3]] + context_crop = caffe.io.resize_image(context_crop, (crop_h, crop_w)) + crop = np.ones(self.crop_dims, dtype=np.float32) * self.crop_mean + crop[pad_y:(pad_y + crop_h), pad_x:(pad_x + crop_w)] = context_crop + + return crop + + def configure_crop(self, context_pad): + """ + Configure crop dimensions and amount of context for cropping. + If context is included, make the special input mean for context padding. + + Parameters + ---------- + context_pad : amount of context for cropping. + """ + # crop dimensions + in_ = self.inputs[0] + tpose = self.transformer.transpose[in_] + inv_tpose = [tpose[t] for t in tpose] + self.crop_dims = np.array(self.blobs[in_].data.shape[1:])[inv_tpose] + #.transpose(inv_tpose) + # context padding + self.context_pad = context_pad + if self.context_pad: + in_ = self.inputs[0] + transpose = self.transformer.transpose.get(in_) + channel_order = self.transformer.channel_swap.get(in_) + raw_scale = self.transformer.raw_scale.get(in_) + # Padding context crops needs the mean in unprocessed input space. + mean = self.transformer.mean.get(in_) + if mean is not None: + inv_transpose = [transpose[t] for t in transpose] + crop_mean = mean.copy().transpose(inv_transpose) + if channel_order is not None: + channel_order_inverse = [channel_order.index(i) + for i in range(crop_mean.shape[2])] + crop_mean = crop_mean[:, :, channel_order_inverse] + if raw_scale is not None: + crop_mean /= raw_scale + self.crop_mean = crop_mean + else: + self.crop_mean = np.zeros(self.crop_dims, dtype=np.float32) diff --git a/python/caffe/detector.pyc b/python/caffe/detector.pyc new file mode 100644 index 0000000..3ec297c Binary files /dev/null and b/python/caffe/detector.pyc differ diff --git a/python/caffe/draw.py b/python/caffe/draw.py new file mode 100644 index 0000000..61205ca --- /dev/null +++ b/python/caffe/draw.py @@ -0,0 +1,222 @@ +""" +Caffe network visualization: draw the NetParameter protobuffer. + + +.. note:: + + This requires pydot>=1.0.2, which is not included in requirements.txt since + it requires graphviz and other prerequisites outside the scope of the + Caffe. +""" + +from caffe.proto import caffe_pb2 + +""" +pydot is not supported under python 3 and pydot2 doesn't work properly. +pydotplus works nicely (pip install pydotplus) +""" +try: + # Try to load pydotplus + import pydotplus as pydot +except ImportError: + import pydot + +# Internal layer and blob styles. +LAYER_STYLE_DEFAULT = {'shape': 'record', + 'fillcolor': '#6495ED', + 'style': 'filled'} +NEURON_LAYER_STYLE = {'shape': 'record', + 'fillcolor': '#90EE90', + 'style': 'filled'} +BLOB_STYLE = {'shape': 'octagon', + 'fillcolor': '#E0E0E0', + 'style': 'filled'} + + +def get_pooling_types_dict(): + """Get dictionary mapping pooling type number to type name + """ + desc = caffe_pb2.PoolingParameter.PoolMethod.DESCRIPTOR + d = {} + for k, v in desc.values_by_name.items(): + d[v.number] = k + return d + + +def get_edge_label(layer): + """Define edge label based on layer type. + """ + + if layer.type == 'Data': + edge_label = 'Batch ' + str(layer.data_param.batch_size) + elif layer.type == 'Convolution' or layer.type == 'Deconvolution': + edge_label = str(layer.convolution_param.num_output) + elif layer.type == 'InnerProduct': + edge_label = str(layer.inner_product_param.num_output) + else: + edge_label = '""' + + return edge_label + + +def get_layer_label(layer, rankdir): + """Define node label based on layer type. + + Parameters + ---------- + layer : ? + rankdir : {'LR', 'TB', 'BT'} + Direction of graph layout. + + Returns + ------- + string : + A label for the current layer + """ + + if rankdir in ('TB', 'BT'): + # If graph orientation is vertical, horizontal space is free and + # vertical space is not; separate words with spaces + separator = ' ' + else: + # If graph orientation is horizontal, vertical space is free and + # horizontal space is not; separate words with newlines + separator = '\\n' + + if layer.type == 'Convolution' or layer.type == 'Deconvolution': + # Outer double quotes needed or else colon characters don't parse + # properly + node_label = '"%s%s(%s)%skernel size: %d%sstride: %d%spad: %d"' %\ + (layer.name, + separator, + layer.type, + separator, + layer.convolution_param.kernel_size[0] if len(layer.convolution_param.kernel_size._values) else 1, + separator, + layer.convolution_param.stride[0] if len(layer.convolution_param.stride._values) else 1, + separator, + layer.convolution_param.pad[0] if len(layer.convolution_param.pad._values) else 0) + elif layer.type == 'Pooling': + pooling_types_dict = get_pooling_types_dict() + node_label = '"%s%s(%s %s)%skernel size: %d%sstride: %d%spad: %d"' %\ + (layer.name, + separator, + pooling_types_dict[layer.pooling_param.pool], + layer.type, + separator, + layer.pooling_param.kernel_size, + separator, + layer.pooling_param.stride, + separator, + layer.pooling_param.pad) + else: + node_label = '"%s%s(%s)"' % (layer.name, separator, layer.type) + return node_label + + +def choose_color_by_layertype(layertype): + """Define colors for nodes based on the layer type. + """ + color = '#6495ED' # Default + if layertype == 'Convolution' or layertype == 'Deconvolution': + color = '#FF5050' + elif layertype == 'Pooling': + color = '#FF9900' + elif layertype == 'InnerProduct': + color = '#CC33FF' + return color + + +def get_pydot_graph(caffe_net, rankdir, label_edges=True): + """Create a data structure which represents the `caffe_net`. + + Parameters + ---------- + caffe_net : object + rankdir : {'LR', 'TB', 'BT'} + Direction of graph layout. + label_edges : boolean, optional + Label the edges (default is True). + + Returns + ------- + pydot graph object + """ + pydot_graph = pydot.Dot(caffe_net.name if caffe_net.name else 'Net', + graph_type='digraph', + rankdir=rankdir) + pydot_nodes = {} + pydot_edges = [] + for layer in caffe_net.layer: + node_label = get_layer_label(layer, rankdir) + node_name = "%s_%s" % (layer.name, layer.type) + if (len(layer.bottom) == 1 and len(layer.top) == 1 and + layer.bottom[0] == layer.top[0]): + # We have an in-place neuron layer. + pydot_nodes[node_name] = pydot.Node(node_label, + **NEURON_LAYER_STYLE) + else: + layer_style = LAYER_STYLE_DEFAULT + layer_style['fillcolor'] = choose_color_by_layertype(layer.type) + pydot_nodes[node_name] = pydot.Node(node_label, **layer_style) + for bottom_blob in layer.bottom: + pydot_nodes[bottom_blob + '_blob'] = pydot.Node('%s' % bottom_blob, + **BLOB_STYLE) + edge_label = '""' + pydot_edges.append({'src': bottom_blob + '_blob', + 'dst': node_name, + 'label': edge_label}) + for top_blob in layer.top: + pydot_nodes[top_blob + '_blob'] = pydot.Node('%s' % (top_blob)) + if label_edges: + edge_label = get_edge_label(layer) + else: + edge_label = '""' + pydot_edges.append({'src': node_name, + 'dst': top_blob + '_blob', + 'label': edge_label}) + # Now, add the nodes and edges to the graph. + for node in pydot_nodes.values(): + pydot_graph.add_node(node) + for edge in pydot_edges: + pydot_graph.add_edge( + pydot.Edge(pydot_nodes[edge['src']], + pydot_nodes[edge['dst']], + label=edge['label'])) + return pydot_graph + + +def draw_net(caffe_net, rankdir, ext='png'): + """Draws a caffe net and returns the image string encoded using the given + extension. + + Parameters + ---------- + caffe_net : a caffe.proto.caffe_pb2.NetParameter protocol buffer. + ext : string, optional + The image extension (the default is 'png'). + + Returns + ------- + string : + Postscript representation of the graph. + """ + return get_pydot_graph(caffe_net, rankdir).create(format=ext) + + +def draw_net_to_file(caffe_net, filename, rankdir='LR'): + """Draws a caffe net, and saves it to file using the format given as the + file extension. Use '.raw' to output raw text that you can manually feed + to graphviz to draw graphs. + + Parameters + ---------- + caffe_net : a caffe.proto.caffe_pb2.NetParameter protocol buffer. + filename : string + The path to a file where the networks visualization will be stored. + rankdir : {'LR', 'TB', 'BT'} + Direction of graph layout. + """ + ext = filename[filename.rfind('.')+1:] + with open(filename, 'wb') as fid: + fid.write(draw_net(caffe_net, rankdir, ext)) diff --git a/python/caffe/draw.pyc b/python/caffe/draw.pyc new file mode 100644 index 0000000..e7a9218 Binary files /dev/null and b/python/caffe/draw.pyc differ diff --git a/python/caffe/imagenet/ilsvrc_2012_mean.npy b/python/caffe/imagenet/ilsvrc_2012_mean.npy new file mode 100644 index 0000000..666082c Binary files /dev/null and b/python/caffe/imagenet/ilsvrc_2012_mean.npy differ diff --git a/python/caffe/io.py b/python/caffe/io.py new file mode 100644 index 0000000..e1759be --- /dev/null +++ b/python/caffe/io.py @@ -0,0 +1,383 @@ +import numpy as np +import skimage.io +from scipy.ndimage import zoom +from skimage.transform import resize + +try: + # Python3 will most likely not be able to load protobuf + from caffe.proto import caffe_pb2 +except: + import sys + if sys.version_info >= (3, 0): + print("Failed to include caffe_pb2, things might go wrong!") + else: + raise + + +## proto / datum / ndarray conversion +def blobproto_to_array(blob, return_diff=False): + """ + Convert a blob proto to an array. In default, we will just return the data, + unless return_diff is True, in which case we will return the diff. + """ + # Read the data into an array + if return_diff: + data = np.array(blob.diff) + else: + data = np.array(blob.data) + + # Reshape the array + if blob.HasField('num') or blob.HasField('channels') or blob.HasField('height') or blob.HasField('width'): + # Use legacy 4D shape + return data.reshape(blob.num, blob.channels, blob.height, blob.width) + else: + return data.reshape(blob.shape.dim) + +def array_to_blobproto(arr, diff=None): + """Converts a N-dimensional array to blob proto. If diff is given, also + convert the diff. You need to make sure that arr and diff have the same + shape, and this function does not do sanity check. + """ + blob = caffe_pb2.BlobProto() + blob.shape.dim.extend(arr.shape) + blob.data.extend(arr.astype(float).flat) + if diff is not None: + blob.diff.extend(diff.astype(float).flat) + return blob + + +def arraylist_to_blobprotovector_str(arraylist): + """Converts a list of arrays to a serialized blobprotovec, which could be + then passed to a network for processing. + """ + vec = caffe_pb2.BlobProtoVector() + vec.blobs.extend([array_to_blobproto(arr) for arr in arraylist]) + return vec.SerializeToString() + + +def blobprotovector_str_to_arraylist(str): + """Converts a serialized blobprotovec to a list of arrays. + """ + vec = caffe_pb2.BlobProtoVector() + vec.ParseFromString(str) + return [blobproto_to_array(blob) for blob in vec.blobs] + + +def array_to_datum(arr, label=None): + """Converts a 3-dimensional array to datum. If the array has dtype uint8, + the output data will be encoded as a string. Otherwise, the output data + will be stored in float format. + """ + if arr.ndim != 3: + raise ValueError('Incorrect array shape.') + datum = caffe_pb2.Datum() + datum.channels, datum.height, datum.width = arr.shape + if arr.dtype == np.uint8: + datum.data = arr.tostring() + else: + datum.float_data.extend(arr.flat) + if label is not None: + datum.label = label + return datum + + +def datum_to_array(datum): + """Converts a datum to an array. Note that the label is not returned, + as one can easily get it by calling datum.label. + """ + if len(datum.data): + return np.fromstring(datum.data, dtype=np.uint8).reshape( + datum.channels, datum.height, datum.width) + else: + return np.array(datum.float_data).astype(float).reshape( + datum.channels, datum.height, datum.width) + + +## Pre-processing + +class Transformer: + """ + Transform input for feeding into a Net. + + Note: this is mostly for illustrative purposes and it is likely better + to define your own input preprocessing routine for your needs. + + Parameters + ---------- + net : a Net for which the input should be prepared + """ + def __init__(self, inputs): + self.inputs = inputs + self.transpose = {} + self.channel_swap = {} + self.raw_scale = {} + self.mean = {} + self.input_scale = {} + + def __check_input(self, in_): + if in_ not in self.inputs: + raise Exception('{} is not one of the net inputs: {}'.format( + in_, self.inputs)) + + def preprocess(self, in_, data): + """ + Format input for Caffe: + - convert to single + - resize to input dimensions (preserving number of channels) + - transpose dimensions to K x H x W + - reorder channels (for instance color to BGR) + - scale raw input (e.g. from [0, 1] to [0, 255] for ImageNet models) + - subtract mean + - scale feature + + Parameters + ---------- + in_ : name of input blob to preprocess for + data : (H' x W' x K) ndarray + + Returns + ------- + caffe_in : (K x H x W) ndarray for input to a Net + """ + self.__check_input(in_) + caffe_in = data.astype(np.float32, copy=False) + transpose = self.transpose.get(in_) + channel_swap = self.channel_swap.get(in_) + raw_scale = self.raw_scale.get(in_) + mean = self.mean.get(in_) + input_scale = self.input_scale.get(in_) + in_dims = self.inputs[in_][2:] + if caffe_in.shape[:2] != in_dims: + caffe_in = resize_image(caffe_in, in_dims) + if transpose is not None: + caffe_in = caffe_in.transpose(transpose) + if channel_swap is not None: + caffe_in = caffe_in[channel_swap, :, :] + if raw_scale is not None: + caffe_in *= raw_scale + if mean is not None: + caffe_in -= mean + if input_scale is not None: + caffe_in *= input_scale + return caffe_in + + def deprocess(self, in_, data): + """ + Invert Caffe formatting; see preprocess(). + """ + self.__check_input(in_) + decaf_in = data.copy().squeeze() + transpose = self.transpose.get(in_) + channel_swap = self.channel_swap.get(in_) + raw_scale = self.raw_scale.get(in_) + mean = self.mean.get(in_) + input_scale = self.input_scale.get(in_) + if input_scale is not None: + decaf_in /= input_scale + if mean is not None: + decaf_in += mean + if raw_scale is not None: + decaf_in /= raw_scale + if channel_swap is not None: + decaf_in = decaf_in[np.argsort(channel_swap), :, :] + if transpose is not None: + decaf_in = decaf_in.transpose(np.argsort(transpose)) + return decaf_in + + def set_transpose(self, in_, order): + """ + Set the input channel order for e.g. RGB to BGR conversion + as needed for the reference ImageNet model. + + Parameters + ---------- + in_ : which input to assign this channel order + order : the order to transpose the dimensions + """ + self.__check_input(in_) + if len(order) != len(self.inputs[in_]) - 1: + raise Exception('Transpose order needs to have the same number of ' + 'dimensions as the input.') + self.transpose[in_] = order + + def set_channel_swap(self, in_, order): + """ + Set the input channel order for e.g. RGB to BGR conversion + as needed for the reference ImageNet model. + N.B. this assumes the channels are the first dimension AFTER transpose. + + Parameters + ---------- + in_ : which input to assign this channel order + order : the order to take the channels. + (2,1,0) maps RGB to BGR for example. + """ + self.__check_input(in_) + if len(order) != self.inputs[in_][1]: + raise Exception('Channel swap needs to have the same number of ' + 'dimensions as the input channels.') + self.channel_swap[in_] = order + + def set_raw_scale(self, in_, scale): + """ + Set the scale of raw features s.t. the input blob = input * scale. + While Python represents images in [0, 1], certain Caffe models + like CaffeNet and AlexNet represent images in [0, 255] so the raw_scale + of these models must be 255. + + Parameters + ---------- + in_ : which input to assign this scale factor + scale : scale coefficient + """ + self.__check_input(in_) + self.raw_scale[in_] = scale + + def set_mean(self, in_, mean): + """ + Set the mean to subtract for centering the data. + + Parameters + ---------- + in_ : which input to assign this mean. + mean : mean ndarray (input dimensional or broadcastable) + """ + self.__check_input(in_) + ms = mean.shape + if mean.ndim == 1: + # broadcast channels + if ms[0] != self.inputs[in_][1]: + raise ValueError('Mean channels incompatible with input.') + mean = mean[:, np.newaxis, np.newaxis] + else: + # elementwise mean + if len(ms) == 2: + ms = (1,) + ms + if len(ms) != 3: + raise ValueError('Mean shape invalid') + if ms != self.inputs[in_][1:]: + raise ValueError('Mean shape incompatible with input shape.') + self.mean[in_] = mean + + def set_input_scale(self, in_, scale): + """ + Set the scale of preprocessed inputs s.t. the blob = blob * scale. + N.B. input_scale is done AFTER mean subtraction and other preprocessing + while raw_scale is done BEFORE. + + Parameters + ---------- + in_ : which input to assign this scale factor + scale : scale coefficient + """ + self.__check_input(in_) + self.input_scale[in_] = scale + + +## Image IO + +def load_image(filename, color=True): + """ + Load an image converting from grayscale or alpha as needed. + + Parameters + ---------- + filename : string + color : boolean + flag for color format. True (default) loads as RGB while False + loads as intensity (if image is already grayscale). + + Returns + ------- + image : an image with type np.float32 in range [0, 1] + of size (H x W x 3) in RGB or + of size (H x W x 1) in grayscale. + """ + img = skimage.img_as_float(skimage.io.imread(filename, as_grey=not color)).astype(np.float32) + if img.ndim == 2: + img = img[:, :, np.newaxis] + if color: + img = np.tile(img, (1, 1, 3)) + elif img.shape[2] == 4: + img = img[:, :, :3] + return img + + +def resize_image(im, new_dims, interp_order=1): + """ + Resize an image array with interpolation. + + Parameters + ---------- + im : (H x W x K) ndarray + new_dims : (height, width) tuple of new dimensions. + interp_order : interpolation order, default is linear. + + Returns + ------- + im : resized ndarray with shape (new_dims[0], new_dims[1], K) + """ + if im.shape[-1] == 1 or im.shape[-1] == 3: + im_min, im_max = im.min(), im.max() + if im_max > im_min: + # skimage is fast but only understands {1,3} channel images + # in [0, 1]. + im_std = (im - im_min) / (im_max - im_min) + resized_std = resize(im_std, new_dims, order=interp_order) + resized_im = resized_std * (im_max - im_min) + im_min + else: + # the image is a constant -- avoid divide by 0 + ret = np.empty((new_dims[0], new_dims[1], im.shape[-1]), + dtype=np.float32) + ret.fill(im_min) + return ret + else: + # ndimage interpolates anything but more slowly. + scale = tuple(np.array(new_dims, dtype=float) / np.array(im.shape[:2])) + resized_im = zoom(im, scale + (1,), order=interp_order) + return resized_im.astype(np.float32) + + +def oversample(images, crop_dims): + """ + Crop images into the four corners, center, and their mirrored versions. + + Parameters + ---------- + image : iterable of (H x W x K) ndarrays + crop_dims : (height, width) tuple for the crops. + + Returns + ------- + crops : (10*N x H x W x K) ndarray of crops for number of inputs N. + """ + # Dimensions and center. + im_shape = np.array(images[0].shape) + crop_dims = np.array(crop_dims) + im_center = im_shape[:2] / 2.0 + + # Make crop coordinates + h_indices = (0, im_shape[0] - crop_dims[0]) + w_indices = (0, im_shape[1] - crop_dims[1]) + crops_ix = np.empty((5, 4), dtype=int) + curr = 0 + for i in h_indices: + for j in w_indices: + crops_ix[curr] = (i, j, i + crop_dims[0], j + crop_dims[1]) + curr += 1 + crops_ix[4] = np.tile(im_center, (1, 2)) + np.concatenate([ + -crop_dims / 2.0, + crop_dims / 2.0 + ]) + crops_ix = np.tile(crops_ix, (2, 1)) + + # Extract crops + crops = np.empty((10 * len(images), crop_dims[0], crop_dims[1], + im_shape[-1]), dtype=np.float32) + ix = 0 + for im in images: + for crop in crops_ix: + crops[ix] = im[crop[0]:crop[2], crop[1]:crop[3], :] + ix += 1 + crops[ix-5:ix] = crops[ix-5:ix, :, ::-1, :] # flip for mirrors + return crops diff --git a/python/caffe/io.pyc b/python/caffe/io.pyc new file mode 100644 index 0000000..1107551 Binary files /dev/null and b/python/caffe/io.pyc differ diff --git a/python/caffe/net_spec.py b/python/caffe/net_spec.py new file mode 100644 index 0000000..5fb1f0b --- /dev/null +++ b/python/caffe/net_spec.py @@ -0,0 +1,226 @@ +"""Python net specification. + +This module provides a way to write nets directly in Python, using a natural, +functional style. See examples/pycaffe/caffenet.py for an example. + +Currently this works as a thin wrapper around the Python protobuf interface, +with layers and parameters automatically generated for the "layers" and +"params" pseudo-modules, which are actually objects using __getattr__ magic +to generate protobuf messages. + +Note that when using to_proto or Top.to_proto, names of intermediate blobs will +be automatically generated. To explicitly specify blob names, use the NetSpec +class -- assign to its attributes directly to name layers, and call +NetSpec.to_proto to serialize all assigned layers. + +This interface is expected to continue to evolve as Caffe gains new capabilities +for specifying nets. In particular, the automatically generated layer names +are not guaranteed to be forward-compatible. +""" + +from collections import OrderedDict, Counter + +from .proto import caffe_pb2 +from google import protobuf +import six + + +def param_name_dict(): + """Find out the correspondence between layer names and parameter names.""" + + layer = caffe_pb2.LayerParameter() + # get all parameter names (typically underscore case) and corresponding + # type names (typically camel case), which contain the layer names + # (note that not all parameters correspond to layers, but we'll ignore that) + param_names = [f.name for f in layer.DESCRIPTOR.fields if f.name.endswith('_param')] + param_type_names = [type(getattr(layer, s)).__name__ for s in param_names] + # strip the final '_param' or 'Parameter' + param_names = [s[:-len('_param')] for s in param_names] + param_type_names = [s[:-len('Parameter')] for s in param_type_names] + return dict(zip(param_type_names, param_names)) + + +def to_proto(*tops): + """Generate a NetParameter that contains all layers needed to compute + all arguments.""" + + layers = OrderedDict() + autonames = Counter() + for top in tops: + top.fn._to_proto(layers, {}, autonames) + net = caffe_pb2.NetParameter() + net.layer.extend(layers.values()) + return net + + +def assign_proto(proto, name, val): + """Assign a Python object to a protobuf message, based on the Python + type (in recursive fashion). Lists become repeated fields/messages, dicts + become messages, and other types are assigned directly. For convenience, + repeated fields whose values are not lists are converted to single-element + lists; e.g., `my_repeated_int_field=3` is converted to + `my_repeated_int_field=[3]`.""" + + is_repeated_field = hasattr(getattr(proto, name), 'extend') + if is_repeated_field and not isinstance(val, list): + val = [val] + if isinstance(val, list): + if isinstance(val[0], dict): + for item in val: + proto_item = getattr(proto, name).add() + for k, v in six.iteritems(item): + assign_proto(proto_item, k, v) + else: + getattr(proto, name).extend(val) + elif isinstance(val, dict): + for k, v in six.iteritems(val): + assign_proto(getattr(proto, name), k, v) + else: + setattr(proto, name, val) + + +class Top(object): + """A Top specifies a single output blob (which could be one of several + produced by a layer.)""" + + def __init__(self, fn, n): + self.fn = fn + self.n = n + + def to_proto(self): + """Generate a NetParameter that contains all layers needed to compute + this top.""" + + return to_proto(self) + + def _to_proto(self, layers, names, autonames): + return self.fn._to_proto(layers, names, autonames) + + +class Function(object): + """A Function specifies a layer, its parameters, and its inputs (which + are Tops from other layers).""" + + def __init__(self, type_name, inputs, params): + self.type_name = type_name + self.inputs = inputs + self.params = params + self.ntop = self.params.get('ntop', 1) + # use del to make sure kwargs are not double-processed as layer params + if 'ntop' in self.params: + del self.params['ntop'] + self.in_place = self.params.get('in_place', False) + if 'in_place' in self.params: + del self.params['in_place'] + self.tops = tuple(Top(self, n) for n in range(self.ntop)) + + def _get_name(self, names, autonames): + if self not in names and self.ntop > 0: + names[self] = self._get_top_name(self.tops[0], names, autonames) + elif self not in names: + autonames[self.type_name] += 1 + names[self] = self.type_name + str(autonames[self.type_name]) + return names[self] + + def _get_top_name(self, top, names, autonames): + if top not in names: + autonames[top.fn.type_name] += 1 + names[top] = top.fn.type_name + str(autonames[top.fn.type_name]) + return names[top] + + def _to_proto(self, layers, names, autonames): + if self in layers: + return + bottom_names = [] + for inp in self.inputs: + inp._to_proto(layers, names, autonames) + bottom_names.append(layers[inp.fn].top[inp.n]) + layer = caffe_pb2.LayerParameter() + layer.type = self.type_name + layer.bottom.extend(bottom_names) + + if self.in_place: + layer.top.extend(layer.bottom) + else: + for top in self.tops: + layer.top.append(self._get_top_name(top, names, autonames)) + layer.name = self._get_name(names, autonames) + + for k, v in six.iteritems(self.params): + # special case to handle generic *params + if k.endswith('param'): + assign_proto(layer, k, v) + else: + try: + assign_proto(getattr(layer, + _param_names[self.type_name] + '_param'), k, v) + except (AttributeError, KeyError): + assign_proto(layer, k, v) + + layers[self] = layer + + +class NetSpec(object): + """A NetSpec contains a set of Tops (assigned directly as attributes). + Calling NetSpec.to_proto generates a NetParameter containing all of the + layers needed to produce all of the assigned Tops, using the assigned + names.""" + + def __init__(self): + super(NetSpec, self).__setattr__('tops', OrderedDict()) + + def __setattr__(self, name, value): + self.tops[name] = value + + def __getattr__(self, name): + return self.tops[name] + + def __setitem__(self, key, value): + self.__setattr__(key, value) + + def __getitem__(self, item): + return self.__getattr__(item) + + def to_proto(self): + names = {v: k for k, v in six.iteritems(self.tops)} + autonames = Counter() + layers = OrderedDict() + for name, top in six.iteritems(self.tops): + top._to_proto(layers, names, autonames) + net = caffe_pb2.NetParameter() + net.layer.extend(layers.values()) + return net + + +class Layers(object): + """A Layers object is a pseudo-module which generates functions that specify + layers; e.g., Layers().Convolution(bottom, kernel_size=3) will produce a Top + specifying a 3x3 convolution applied to bottom.""" + + def __getattr__(self, name): + def layer_fn(*args, **kwargs): + fn = Function(name, args, kwargs) + if fn.ntop == 0: + return fn + elif fn.ntop == 1: + return fn.tops[0] + else: + return fn.tops + return layer_fn + + +class Parameters(object): + """A Parameters object is a pseudo-module which generates constants used + in layer parameters; e.g., Parameters().Pooling.MAX is the value used + to specify max pooling.""" + + def __getattr__(self, name): + class Param: + def __getattr__(self, param_name): + return getattr(getattr(caffe_pb2, name + 'Parameter'), param_name) + return Param() + + +_param_names = param_name_dict() +layers = Layers() +params = Parameters() diff --git a/python/caffe/net_spec.pyc b/python/caffe/net_spec.pyc new file mode 100644 index 0000000..c22adb0 Binary files /dev/null and b/python/caffe/net_spec.pyc differ diff --git a/python/caffe/proto/caffe_pb2.py b/python/caffe/proto/caffe_pb2.py new file mode 100644 index 0000000..42db180 --- /dev/null +++ b/python/caffe/proto/caffe_pb2.py @@ -0,0 +1,7353 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: caffe.proto + +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='caffe.proto', + package='caffe', + serialized_pb='\n\x0b\x63\x61\x66\x66\x65.proto\x12\x05\x63\x61\x66\x66\x65\"\x1c\n\tBlobShape\x12\x0f\n\x03\x64im\x18\x01 \x03(\x03\x42\x02\x10\x01\"\xcc\x01\n\tBlobProto\x12\x1f\n\x05shape\x18\x07 \x01(\x0b\x32\x10.caffe.BlobShape\x12\x10\n\x04\x64\x61ta\x18\x05 \x03(\x02\x42\x02\x10\x01\x12\x10\n\x04\x64iff\x18\x06 \x03(\x02\x42\x02\x10\x01\x12\x17\n\x0b\x64ouble_data\x18\x08 \x03(\x01\x42\x02\x10\x01\x12\x17\n\x0b\x64ouble_diff\x18\t \x03(\x01\x42\x02\x10\x01\x12\x0e\n\x03num\x18\x01 \x01(\x05:\x01\x30\x12\x13\n\x08\x63hannels\x18\x02 \x01(\x05:\x01\x30\x12\x11\n\x06height\x18\x03 \x01(\x05:\x01\x30\x12\x10\n\x05width\x18\x04 \x01(\x05:\x01\x30\"2\n\x0f\x42lobProtoVector\x12\x1f\n\x05\x62lobs\x18\x01 \x03(\x0b\x32\x10.caffe.BlobProto\"\x81\x01\n\x05\x44\x61tum\x12\x10\n\x08\x63hannels\x18\x01 \x01(\x05\x12\x0e\n\x06height\x18\x02 \x01(\x05\x12\r\n\x05width\x18\x03 \x01(\x05\x12\x0c\n\x04\x64\x61ta\x18\x04 \x01(\x0c\x12\r\n\x05label\x18\x05 \x01(\x05\x12\x12\n\nfloat_data\x18\x06 \x03(\x02\x12\x16\n\x07\x65ncoded\x18\x07 \x01(\x08:\x05\x66\x61lse\"\xaa\x02\n\x0f\x46illerParameter\x12\x16\n\x04type\x18\x01 \x01(\t:\x08\x63onstant\x12\x10\n\x05value\x18\x02 \x01(\x02:\x01\x30\x12\x0e\n\x03min\x18\x03 \x01(\x02:\x01\x30\x12\x0e\n\x03max\x18\x04 \x01(\x02:\x01\x31\x12\x0f\n\x04mean\x18\x05 \x01(\x02:\x01\x30\x12\x0e\n\x03std\x18\x06 \x01(\x02:\x01\x31\x12\x12\n\x06sparse\x18\x07 \x01(\x05:\x02-1\x12\x42\n\rvariance_norm\x18\x08 \x01(\x0e\x32#.caffe.FillerParameter.VarianceNorm:\x06\x46\x41N_IN\x12\x10\n\x08\x64iag_val\x18\t \x03(\x02\x12\x0c\n\x04\x66ile\x18\n \x01(\t\"4\n\x0cVarianceNorm\x12\n\n\x06\x46\x41N_IN\x10\x00\x12\x0b\n\x07\x46\x41N_OUT\x10\x01\x12\x0b\n\x07\x41VERAGE\x10\x02\"\x8e\x02\n\x0cNetParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\r\n\x05input\x18\x03 \x03(\t\x12%\n\x0binput_shape\x18\x08 \x03(\x0b\x32\x10.caffe.BlobShape\x12\x11\n\tinput_dim\x18\x04 \x03(\x05\x12\x1d\n\x0e\x66orce_backward\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x05state\x18\x06 \x01(\x0b\x32\x0f.caffe.NetState\x12\x19\n\ndebug_info\x18\x07 \x01(\x08:\x05\x66\x61lse\x12$\n\x05layer\x18\x64 \x03(\x0b\x32\x15.caffe.LayerParameter\x12\'\n\x06layers\x18\x02 \x03(\x0b\x32\x17.caffe.V1LayerParameter\"\x9c\n\n\x0fSolverParameter\x12\x0b\n\x03net\x18\x18 \x01(\t\x12&\n\tnet_param\x18\x19 \x01(\x0b\x32\x13.caffe.NetParameter\x12\x11\n\ttrain_net\x18\x01 \x01(\t\x12\x10\n\x08test_net\x18\x02 \x03(\t\x12,\n\x0ftrain_net_param\x18\x15 \x01(\x0b\x32\x13.caffe.NetParameter\x12+\n\x0etest_net_param\x18\x16 \x03(\x0b\x32\x13.caffe.NetParameter\x12$\n\x0btrain_state\x18\x1a \x01(\x0b\x32\x0f.caffe.NetState\x12#\n\ntest_state\x18\x1b \x03(\x0b\x32\x0f.caffe.NetState\x12\x11\n\ttest_iter\x18\x03 \x03(\x05\x12\x18\n\rtest_interval\x18\x04 \x01(\x05:\x01\x30\x12 \n\x11test_compute_loss\x18\x13 \x01(\x08:\x05\x66\x61lse\x12!\n\x13test_initialization\x18 \x01(\x08:\x04true\x12\x0f\n\x07\x62\x61se_lr\x18\x05 \x01(\x02\x12\x0f\n\x07\x64isplay\x18\x06 \x01(\x05\x12\x17\n\x0c\x61verage_loss\x18! \x01(\x05:\x01\x31\x12\x10\n\x08max_iter\x18\x07 \x01(\x05\x12\x14\n\titer_size\x18$ \x01(\x05:\x01\x31\x12\x11\n\tlr_policy\x18\x08 \x01(\t\x12\r\n\x05gamma\x18\t \x01(\x02\x12\r\n\x05power\x18\n \x01(\x02\x12\x10\n\x08momentum\x18\x0b \x01(\x02\x12\x14\n\x0cweight_decay\x18\x0c \x01(\x02\x12\x1f\n\x13regularization_type\x18\x1d \x01(\t:\x02L2\x12\x10\n\x08stepsize\x18\r \x01(\x05\x12\x11\n\tstepvalue\x18\" \x03(\x05\x12\x1a\n\x0e\x63lip_gradients\x18# \x01(\x02:\x02-1\x12\x13\n\x08snapshot\x18\x0e \x01(\x05:\x01\x30\x12\x17\n\x0fsnapshot_prefix\x18\x0f \x01(\t\x12\x1c\n\rsnapshot_diff\x18\x10 \x01(\x08:\x05\x66\x61lse\x12K\n\x0fsnapshot_format\x18% \x01(\x0e\x32%.caffe.SolverParameter.SnapshotFormat:\x0b\x42INARYPROTO\x12;\n\x0bsolver_mode\x18\x11 \x01(\x0e\x32!.caffe.SolverParameter.SolverMode:\x03GPU\x12\x14\n\tdevice_id\x18\x12 \x01(\x05:\x01\x30\x12\x17\n\x0brandom_seed\x18\x14 \x01(\x03:\x02-1\x12\x11\n\x04type\x18( \x01(\t:\x03SGD\x12\x14\n\x05\x64\x65lta\x18\x1f \x01(\x02:\x05\x31\x65-08\x12\x18\n\tmomentum2\x18\' \x01(\x02:\x05\x30.999\x12\x11\n\trms_decay\x18& \x01(\x02\x12\x19\n\ndebug_info\x18\x17 \x01(\x08:\x05\x66\x61lse\x12\"\n\x14snapshot_after_train\x18\x1c \x01(\x08:\x04true\x12;\n\x0bsolver_type\x18\x1e \x01(\x0e\x32!.caffe.SolverParameter.SolverType:\x03SGD\"+\n\x0eSnapshotFormat\x12\x08\n\x04HDF5\x10\x00\x12\x0f\n\x0b\x42INARYPROTO\x10\x01\"\x1e\n\nSolverMode\x12\x07\n\x03\x43PU\x10\x00\x12\x07\n\x03GPU\x10\x01\"U\n\nSolverType\x12\x07\n\x03SGD\x10\x00\x12\x0c\n\x08NESTEROV\x10\x01\x12\x0b\n\x07\x41\x44\x41GRAD\x10\x02\x12\x0b\n\x07RMSPROP\x10\x03\x12\x0c\n\x08\x41\x44\x41\x44\x45LTA\x10\x04\x12\x08\n\x04\x41\x44\x41M\x10\x05\"l\n\x0bSolverState\x12\x0c\n\x04iter\x18\x01 \x01(\x05\x12\x13\n\x0blearned_net\x18\x02 \x01(\t\x12!\n\x07history\x18\x03 \x03(\x0b\x32\x10.caffe.BlobProto\x12\x17\n\x0c\x63urrent_step\x18\x04 \x01(\x05:\x01\x30\"N\n\x08NetState\x12!\n\x05phase\x18\x01 \x01(\x0e\x32\x0c.caffe.Phase:\x04TEST\x12\x10\n\x05level\x18\x02 \x01(\x05:\x01\x30\x12\r\n\x05stage\x18\x03 \x03(\t\"s\n\x0cNetStateRule\x12\x1b\n\x05phase\x18\x01 \x01(\x0e\x32\x0c.caffe.Phase\x12\x11\n\tmin_level\x18\x02 \x01(\x05\x12\x11\n\tmax_level\x18\x03 \x01(\x05\x12\r\n\x05stage\x18\x04 \x03(\t\x12\x11\n\tnot_stage\x18\x05 \x03(\t\"\xa3\x01\n\tParamSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x31\n\nshare_mode\x18\x02 \x01(\x0e\x32\x1d.caffe.ParamSpec.DimCheckMode\x12\x12\n\x07lr_mult\x18\x03 \x01(\x02:\x01\x31\x12\x15\n\ndecay_mult\x18\x04 \x01(\x02:\x01\x31\"*\n\x0c\x44imCheckMode\x12\n\n\x06STRICT\x10\x00\x12\x0e\n\nPERMISSIVE\x10\x01\"\xde\x18\n\x0eLayerParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\x12\x0e\n\x06\x62ottom\x18\x03 \x03(\t\x12\x0b\n\x03top\x18\x04 \x03(\t\x12\x1b\n\x05phase\x18\n \x01(\x0e\x32\x0c.caffe.Phase\x12\x13\n\x0bloss_weight\x18\x05 \x03(\x02\x12\x1f\n\x05param\x18\x06 \x03(\x0b\x32\x10.caffe.ParamSpec\x12\x1f\n\x05\x62lobs\x18\x07 \x03(\x0b\x32\x10.caffe.BlobProto\x12\x16\n\x0epropagate_down\x18\x0b \x03(\x08\x12$\n\x07include\x18\x08 \x03(\x0b\x32\x13.caffe.NetStateRule\x12$\n\x07\x65xclude\x18\t \x03(\x0b\x32\x13.caffe.NetStateRule\x12\x37\n\x0ftransform_param\x18\x64 \x01(\x0b\x32\x1e.caffe.TransformationParameter\x12(\n\nloss_param\x18\x65 \x01(\x0b\x32\x14.caffe.LossParameter\x12\x30\n\x0e\x61\x63\x63uracy_param\x18\x66 \x01(\x0b\x32\x18.caffe.AccuracyParameter\x12,\n\x0c\x61rgmax_param\x18g \x01(\x0b\x32\x16.caffe.ArgMaxParameter\x12\x34\n\x10\x62\x61tch_norm_param\x18\x8b\x01 \x01(\x0b\x32\x19.caffe.BatchNormParameter\x12)\n\nbias_param\x18\x8d\x01 \x01(\x0b\x32\x14.caffe.BiasParameter\x12,\n\x0c\x63oncat_param\x18h \x01(\x0b\x32\x16.caffe.ConcatParameter\x12?\n\x16\x63ontrastive_loss_param\x18i \x01(\x0b\x32\x1f.caffe.ContrastiveLossParameter\x12\x36\n\x11\x63onvolution_param\x18j \x01(\x0b\x32\x1b.caffe.ConvolutionParameter\x12)\n\ncrop_param\x18\x90\x01 \x01(\x0b\x32\x14.caffe.CropParameter\x12(\n\ndata_param\x18k \x01(\x0b\x32\x14.caffe.DataParameter\x12.\n\rdropout_param\x18l \x01(\x0b\x32\x17.caffe.DropoutParameter\x12\x33\n\x10\x64ummy_data_param\x18m \x01(\x0b\x32\x19.caffe.DummyDataParameter\x12.\n\reltwise_param\x18n \x01(\x0b\x32\x17.caffe.EltwiseParameter\x12\'\n\telu_param\x18\x8c\x01 \x01(\x0b\x32\x13.caffe.ELUParameter\x12+\n\x0b\x65mbed_param\x18\x89\x01 \x01(\x0b\x32\x15.caffe.EmbedParameter\x12&\n\texp_param\x18o \x01(\x0b\x32\x13.caffe.ExpParameter\x12-\n\x0c\x65xpmax_param\x18\x9e\x01 \x01(\x0b\x32\x16.caffe.ExpMaxParameter\x12/\n\rflatten_param\x18\x87\x01 \x01(\x0b\x32\x17.caffe.FlattenParameter\x12\x31\n\x0fhdf5_data_param\x18p \x01(\x0b\x32\x18.caffe.HDF5DataParameter\x12\x35\n\x11hdf5_output_param\x18q \x01(\x0b\x32\x1a.caffe.HDF5OutputParameter\x12\x33\n\x10hinge_loss_param\x18r \x01(\x0b\x32\x19.caffe.HingeLossParameter\x12\x33\n\x10image_data_param\x18s \x01(\x0b\x32\x19.caffe.ImageDataParameter\x12\x39\n\x13infogain_loss_param\x18t \x01(\x0b\x32\x1c.caffe.InfogainLossParameter\x12\x39\n\x13inner_product_param\x18u \x01(\x0b\x32\x1c.caffe.InnerProductParameter\x12+\n\x0binput_param\x18\x8f\x01 \x01(\x0b\x32\x15.caffe.InputParameter\x12\'\n\tlog_param\x18\x86\x01 \x01(\x0b\x32\x13.caffe.LogParameter\x12&\n\tlrn_param\x18v \x01(\x0b\x32\x13.caffe.LRNParameter\x12\x35\n\x11memory_data_param\x18w \x01(\x0b\x32\x1a.caffe.MemoryDataParameter\x12&\n\tmvn_param\x18x \x01(\x0b\x32\x13.caffe.MVNParameter\x12\x33\n\x0fparameter_param\x18\x91\x01 \x01(\x0b\x32\x19.caffe.ParameterParameter\x12.\n\rpooling_param\x18y \x01(\x0b\x32\x17.caffe.PoolingParameter\x12*\n\x0bpower_param\x18z \x01(\x0b\x32\x15.caffe.PowerParameter\x12+\n\x0bprelu_param\x18\x83\x01 \x01(\x0b\x32\x15.caffe.PReLUParameter\x12-\n\x0cpython_param\x18\x82\x01 \x01(\x0b\x32\x16.caffe.PythonParameter\x12\x33\n\x0frecurrent_param\x18\x92\x01 \x01(\x0b\x32\x19.caffe.RecurrentParameter\x12\x33\n\x0freduction_param\x18\x88\x01 \x01(\x0b\x32\x19.caffe.ReductionParameter\x12(\n\nrelu_param\x18{ \x01(\x0b\x32\x14.caffe.ReLUParameter\x12/\n\rreshape_param\x18\x85\x01 \x01(\x0b\x32\x17.caffe.ReshapeParameter\x12+\n\x0bscale_param\x18\x8e\x01 \x01(\x0b\x32\x15.caffe.ScaleParameter\x12.\n\rsigmoid_param\x18| \x01(\x0b\x32\x17.caffe.SigmoidParameter\x12.\n\rsoftmax_param\x18} \x01(\x0b\x32\x17.caffe.SoftmaxParameter\x12\'\n\tspp_param\x18\x84\x01 \x01(\x0b\x32\x13.caffe.SPPParameter\x12*\n\x0bslice_param\x18~ \x01(\x0b\x32\x15.caffe.SliceParameter\x12(\n\ntanh_param\x18\x7f \x01(\x0b\x32\x14.caffe.TanHParameter\x12\x33\n\x0fthreshold_param\x18\x80\x01 \x01(\x0b\x32\x19.caffe.ThresholdParameter\x12)\n\ntile_param\x18\x8a\x01 \x01(\x0b\x32\x14.caffe.TileParameter\x12\x36\n\x11window_data_param\x18\x81\x01 \x01(\x0b\x32\x1a.caffe.WindowDataParameter\x12<\n\x14\x63oeff_schedule_param\x18\x94\x01 \x01(\x0b\x32\x1d.caffe.CoeffScheduleParameter\x12\x39\n\x12\x61ugmentation_param\x18\x95\x01 \x01(\x0b\x32\x1c.caffe.AugmentationParameter\x12\x37\n\x11\x63orrelation_param\x18\x96\x01 \x01(\x0b\x32\x1b.caffe.CorrelationParameter\x12.\n\rl1_loss_param\x18\x97\x01 \x01(\x0b\x32\x16.caffe.L1LossParameter\x12-\n\x0cwriter_param\x18\x98\x01 \x01(\x0b\x32\x16.caffe.WriterParameter\x12-\n\x0creader_param\x18\x99\x01 \x01(\x0b\x32\x16.caffe.ReaderParameter\x12)\n\nmean_param\x18\x9a\x01 \x01(\x0b\x32\x14.caffe.MeanParameter\x12\x31\n\x0eresample_param\x18\x9b\x01 \x01(\x0b\x32\x18.caffe.ResampleParameter\x12\x35\n\x10\x64ownsample_param\x18\x9c\x01 \x01(\x0b\x32\x1a.caffe.DownsampleParameter\x12\x33\n\x0fnegsquare_param\x18\x9f\x01 \x01(\x0b\x32\x19.caffe.NegSquareParameter\x12!\n\x12reshape_every_iter\x18\x9d\x01 \x01(\x08:\x04true\"=\n\rGridParameter\x12\x0e\n\x06height\x18\x01 \x01(\r\x12\r\n\x05width\x18\x02 \x01(\r\x12\r\n\x05\x62\x61tch\x18\x03 \x01(\r\"\xde\x07\n\x11\x41ugmentationCoeff\x12\x11\n\x06mirror\x18\x01 \x01(\x02:\x01\x30\x12\r\n\x02\x64x\x18\x02 \x01(\x02:\x01\x30\x12\r\n\x02\x64y\x18\x03 \x01(\x02:\x01\x30\x12\x10\n\x05\x61ngle\x18\x04 \x01(\x02:\x01\x30\x12\x11\n\x06zoom_x\x18\x05 \x01(\x02:\x01\x31\x12\x11\n\x06zoom_y\x18\x06 \x01(\x02:\x01\x31\x12\x10\n\x05gamma\x18\x64 \x01(\x02:\x01\x31\x12\x15\n\nbrightness\x18\x65 \x01(\x02:\x01\x30\x12\x13\n\x08\x63ontrast\x18\x66 \x01(\x02:\x01\x31\x12\x11\n\x06\x63olor1\x18g \x01(\x02:\x01\x31\x12\x11\n\x06\x63olor2\x18h \x01(\x02:\x01\x31\x12\x11\n\x06\x63olor3\x18i \x01(\x02:\x01\x31\x12\x16\n\x0bpow_nomean0\x18\n \x01(\x02:\x01\x31\x12\x16\n\x0bpow_nomean1\x18\x0b \x01(\x02:\x01\x31\x12\x16\n\x0bpow_nomean2\x18\x0c \x01(\x02:\x01\x31\x12\x16\n\x0b\x61\x64\x64_nomean0\x18\r \x01(\x02:\x01\x30\x12\x16\n\x0b\x61\x64\x64_nomean1\x18\x0e \x01(\x02:\x01\x30\x12\x16\n\x0b\x61\x64\x64_nomean2\x18\x0f \x01(\x02:\x01\x30\x12\x17\n\x0cmult_nomean0\x18\x10 \x01(\x02:\x01\x31\x12\x17\n\x0cmult_nomean1\x18\x11 \x01(\x02:\x01\x31\x12\x17\n\x0cmult_nomean2\x18\x12 \x01(\x02:\x01\x31\x12\x18\n\rpow_withmean0\x18\x13 \x01(\x02:\x01\x31\x12\x18\n\rpow_withmean1\x18\x14 \x01(\x02:\x01\x31\x12\x18\n\rpow_withmean2\x18\x15 \x01(\x02:\x01\x31\x12\x18\n\radd_withmean0\x18\x16 \x01(\x02:\x01\x30\x12\x18\n\radd_withmean1\x18\x17 \x01(\x02:\x01\x30\x12\x18\n\radd_withmean2\x18\x18 \x01(\x02:\x01\x30\x12\x19\n\x0emult_withmean0\x18\x19 \x01(\x02:\x01\x31\x12\x19\n\x0emult_withmean1\x18\x1a \x01(\x02:\x01\x31\x12\x19\n\x0emult_withmean2\x18\x1b \x01(\x02:\x01\x31\x12\x14\n\tlmult_pow\x18\x1c \x01(\x02:\x01\x31\x12\x14\n\tlmult_add\x18\x1d \x01(\x02:\x01\x30\x12\x15\n\nlmult_mult\x18\x1e \x01(\x02:\x01\x31\x12\x14\n\tcol_angle\x18\x1f \x01(\x02:\x01\x30\x12\x15\n\nfog_amount\x18& \x01(\x02:\x01\x30\x12\x13\n\x08\x66og_size\x18\' \x01(\x02:\x01\x30\x12\x1c\n\x11motion_blur_angle\x18( \x01(\x02:\x01\x30\x12\x1b\n\x10motion_blur_size\x18) \x01(\x02:\x01\x30\x12\x17\n\x0cshadow_angle\x18* \x01(\x02:\x01\x30\x12\x1a\n\x0fshadow_distance\x18+ \x01(\x02:\x01\x30\x12\x1a\n\x0fshadow_strength\x18, \x01(\x02:\x01\x30\x12\x10\n\x05noise\x18- \x01(\x02:\x01\x30\"\xec\x0f\n\x15\x41ugmentationParameter\x12\x15\n\ncrop_width\x18! \x01(\r:\x01\x30\x12\x16\n\x0b\x63rop_height\x18\" \x01(\r:\x01\x30\x12\x19\n\x0fwrite_augmented\x18\x02 \x01(\t:\x00\x12\x1b\n\x0emax_multiplier\x18\x03 \x01(\x02:\x03\x32\x35\x35\x12\"\n\x13\x61ugment_during_test\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\x19\n\x0erecompute_mean\x18\x05 \x01(\r:\x01\x30\x12\x14\n\nwrite_mean\x18\x06 \x01(\t:\x00\x12\x1c\n\x0emean_per_pixel\x18\x07 \x01(\x08:\x04true\x12\x0c\n\x04mean\x18\x12 \x03(\x02\x12\x11\n\x04mode\x18\x08 \x01(\t:\x03\x61\x64\x64\x12\x16\n\x0b\x62ottomwidth\x18P \x01(\r:\x01\x30\x12\x17\n\x0c\x62ottomheight\x18Q \x01(\r:\x01\x30\x12\x0e\n\x03num\x18R \x01(\r:\x01\x30\x12\x18\n\x10\x63hromatic_eigvec\x18S \x03(\x02\x12/\n\x06mirror\x18\n \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x32\n\ttranslate\x18\x0b \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12/\n\x06rotate\x18\x0c \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12-\n\x04zoom\x18\r \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x30\n\x07squeeze\x18\x0e \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x34\n\x0btranslate_x\x18\x0f \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x34\n\x0btranslate_y\x18\x10 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12.\n\x05gamma\x18# \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x33\n\nbrightness\x18$ \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x31\n\x08\x63ontrast\x18% \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12.\n\x05\x63olor\x18& \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x32\n\tlmult_pow\x18\x14 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x33\n\nlmult_mult\x18\x15 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x32\n\tlmult_add\x18\x16 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x30\n\x07sat_pow\x18\x17 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x31\n\x08sat_mult\x18\x18 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x30\n\x07sat_add\x18\x19 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x30\n\x07\x63ol_pow\x18\x1a \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x31\n\x08\x63ol_mult\x18\x1b \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x30\n\x07\x63ol_add\x18\x1c \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x31\n\x08ladd_pow\x18\x1d \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x32\n\tladd_mult\x18\x1e \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x31\n\x08ladd_add\x18\x1f \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x33\n\ncol_rotate\x18 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x33\n\nfog_amount\x18\x64 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x31\n\x08\x66og_size\x18\x65 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12:\n\x11motion_blur_angle\x18\x66 \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x39\n\x10motion_blur_size\x18g \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x35\n\x0cshadow_angle\x18h \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x38\n\x0fshadow_distance\x18i \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12\x38\n\x0fshadow_strength\x18j \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\x12.\n\x05noise\x18k \x01(\x0b\x32\x1f.caffe.RandomGeneratorParameter\"\xcf\x01\n\x18RandomGeneratorParameter\x12\x1a\n\trand_type\x18\x01 \x01(\t:\x07uniform\x12\x12\n\x03\x65xp\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x0f\n\x04mean\x18\x04 \x01(\x02:\x01\x30\x12\x11\n\x06spread\x18\x05 \x01(\x02:\x01\x30\x12\x0f\n\x04prob\x18\x06 \x01(\x02:\x01\x31\x12\x1c\n\x0e\x61pply_schedule\x18\x07 \x01(\x08:\x04true\x12\x19\n\ndiscretize\x18\x08 \x01(\x08:\x05\x66\x61lse\x12\x15\n\nmultiplier\x18\t \x01(\x02:\x01\x31\"\xc2\x01\n\x0fL1LossParameter\x12\x1e\n\x0fl2_per_location\x18\x01 \x01(\x08:\x05\x66\x61lse\x12&\n\x17l2_prescale_by_channels\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\'\n\x18normalize_by_num_entries\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x15\n\x07\x65psilon\x18\x04 \x01(\x02:\x04\x30.01\x12\x13\n\x07plateau\x18\xb9\x17 \x01(\x02:\x01\x30\x12\x12\n\x05power\x18\x05 \x01(\x02:\x03\x30.5\"\xb3\x02\n\x14\x43orrelationParameter\x12\x0e\n\x03pad\x18\x02 \x01(\r:\x01\x30\x12\x13\n\x0bkernel_size\x18\x03 \x01(\r\x12\x18\n\x10max_displacement\x18\x04 \x01(\r\x12\x13\n\x08stride_1\x18\x05 \x01(\r:\x01\x31\x12\x13\n\x08stride_2\x18\x06 \x01(\r:\x01\x31\x12\x1b\n\x10single_direction\x18\x08 \x01(\x05:\x01\x30\x12\x15\n\x06\x64o_abs\x18\x07 \x01(\x08:\x05\x66\x61lse\x12O\n\x10\x63orrelation_type\x18\x0f \x01(\x0e\x32+.caffe.CorrelationParameter.CorrelationType:\x08MULTIPLY\"-\n\x0f\x43orrelationType\x12\x0c\n\x08MULTIPLY\x10\x00\x12\x0c\n\x08SUBTRACT\x10\x01\"B\n\x13\x44ownsampleParameter\x12\x15\n\ntop_height\x18\x01 \x01(\r:\x01\x30\x12\x14\n\ttop_width\x18\x02 \x01(\r:\x01\x30\"/\n\x0fReaderParameter\x12\x0c\n\x04\x66ile\x18\x01 \x02(\t\x12\x0e\n\x03num\x18\x02 \x01(\r:\x01\x31\"\x83\x01\n\x0fWriterParameter\x12\x0e\n\x04\x66ile\x18\x01 \x01(\t:\x00\x12\x10\n\x06\x66older\x18\x02 \x01(\t:\x00\x12\x10\n\x06prefix\x18\x03 \x01(\t:\x00\x12\x10\n\x06suffix\x18\x04 \x01(\t:\x00\x12\x18\n\tnormalize\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x10\n\x05scale\x18\x06 \x01(\x02:\x01\x31\"\xc6\x01\n\x11ResampleParameter\x12\x17\n\tantialias\x18\x04 \x01(\x08:\x04true\x12\r\n\x05width\x18\x01 \x01(\r\x12\x0e\n\x06height\x18\x02 \x01(\r\x12;\n\x04type\x18\x03 \x01(\x0e\x32%.caffe.ResampleParameter.ResampleType:\x06LINEAR\"<\n\x0cResampleType\x12\x0b\n\x07NEAREST\x10\x01\x12\n\n\x06LINEAR\x10\x02\x12\t\n\x05\x43UBIC\x10\x03\x12\x08\n\x04\x41REA\x10\x04\"\xd3\x01\n\rMeanParameter\x12\x35\n\toperation\x18\x01 \x02(\x0e\x32\".caffe.MeanParameter.MeanOperation\x12\x0c\n\x04\x66ile\x18\x02 \x01(\t\x12\r\n\x05value\x18\x03 \x03(\x02\x12\x15\n\nmean_scale\x18\x04 \x01(\x02:\x01\x31\x12\x16\n\x0binput_scale\x18\x05 \x01(\x02:\x01\x31\x12\x17\n\x0coutput_scale\x18\x06 \x01(\x02:\x01\x31\"&\n\rMeanOperation\x12\x07\n\x03\x41\x44\x44\x10\x01\x12\x0c\n\x08SUBTRACT\x10\x04\"`\n\x16\x43oeffScheduleParameter\x12\x14\n\thalf_life\x18\x01 \x01(\x02:\x01\x31\x12\x18\n\rinitial_coeff\x18\x02 \x01(\x02:\x01\x31\x12\x16\n\x0b\x66inal_coeff\x18\x03 \x01(\x02:\x01\x31\"\xb6\x01\n\x17TransformationParameter\x12\x10\n\x05scale\x18\x01 \x01(\x02:\x01\x31\x12\x15\n\x06mirror\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x14\n\tcrop_size\x18\x03 \x01(\r:\x01\x30\x12\x11\n\tmean_file\x18\x04 \x01(\t\x12\x12\n\nmean_value\x18\x05 \x03(\x02\x12\x1a\n\x0b\x66orce_color\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x19\n\nforce_gray\x18\x07 \x01(\x08:\x05\x66\x61lse\"\xc2\x01\n\rLossParameter\x12\x14\n\x0cignore_label\x18\x01 \x01(\x05\x12\x44\n\rnormalization\x18\x03 \x01(\x0e\x32&.caffe.LossParameter.NormalizationMode:\x05VALID\x12\x11\n\tnormalize\x18\x02 \x01(\x08\"B\n\x11NormalizationMode\x12\x08\n\x04\x46ULL\x10\x00\x12\t\n\x05VALID\x10\x01\x12\x0e\n\nBATCH_SIZE\x10\x02\x12\x08\n\x04NONE\x10\x03\"L\n\x11\x41\x63\x63uracyParameter\x12\x10\n\x05top_k\x18\x01 \x01(\r:\x01\x31\x12\x0f\n\x04\x61xis\x18\x02 \x01(\x05:\x01\x31\x12\x14\n\x0cignore_label\x18\x03 \x01(\x05\"M\n\x0f\x41rgMaxParameter\x12\x1a\n\x0bout_max_val\x18\x01 \x01(\x08:\x05\x66\x61lse\x12\x10\n\x05top_k\x18\x02 \x01(\r:\x01\x31\x12\x0c\n\x04\x61xis\x18\x03 \x01(\x05\"9\n\x0f\x43oncatParameter\x12\x0f\n\x04\x61xis\x18\x02 \x01(\x05:\x01\x31\x12\x15\n\nconcat_dim\x18\x01 \x01(\r:\x01\x31\"j\n\x12\x42\x61tchNormParameter\x12\x18\n\x10use_global_stats\x18\x01 \x01(\x08\x12&\n\x17moving_average_fraction\x18\x02 \x01(\x02:\x05\x30.999\x12\x12\n\x03\x65ps\x18\x03 \x01(\x02:\x05\x31\x65-05\"]\n\rBiasParameter\x12\x0f\n\x04\x61xis\x18\x01 \x01(\x05:\x01\x31\x12\x13\n\x08num_axes\x18\x02 \x01(\x05:\x01\x31\x12&\n\x06\x66iller\x18\x03 \x01(\x0b\x32\x16.caffe.FillerParameter\"L\n\x18\x43ontrastiveLossParameter\x12\x11\n\x06margin\x18\x01 \x01(\x02:\x01\x31\x12\x1d\n\x0elegacy_version\x18\x02 \x01(\x08:\x05\x66\x61lse\"\xfc\x03\n\x14\x43onvolutionParameter\x12\x12\n\nnum_output\x18\x01 \x01(\r\x12\x17\n\tbias_term\x18\x02 \x01(\x08:\x04true\x12\x0b\n\x03pad\x18\x03 \x03(\r\x12\x13\n\x0bkernel_size\x18\x04 \x03(\r\x12\x0e\n\x06stride\x18\x06 \x03(\r\x12\x10\n\x08\x64ilation\x18\x12 \x03(\r\x12\x10\n\x05pad_h\x18\t \x01(\r:\x01\x30\x12\x10\n\x05pad_w\x18\n \x01(\r:\x01\x30\x12\x10\n\x08kernel_h\x18\x0b \x01(\r\x12\x10\n\x08kernel_w\x18\x0c \x01(\r\x12\x10\n\x08stride_h\x18\r \x01(\r\x12\x10\n\x08stride_w\x18\x0e \x01(\r\x12\x10\n\x05group\x18\x05 \x01(\r:\x01\x31\x12-\n\rweight_filler\x18\x07 \x01(\x0b\x32\x16.caffe.FillerParameter\x12+\n\x0b\x62ias_filler\x18\x08 \x01(\x0b\x32\x16.caffe.FillerParameter\x12;\n\x06\x65ngine\x18\x0f \x01(\x0e\x32\".caffe.ConvolutionParameter.Engine:\x07\x44\x45\x46\x41ULT\x12\x0f\n\x04\x61xis\x18\x10 \x01(\x05:\x01\x31\x12\x1e\n\x0f\x66orce_nd_im2col\x18\x11 \x01(\x08:\x05\x66\x61lse\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"0\n\rCropParameter\x12\x0f\n\x04\x61xis\x18\x01 \x01(\x05:\x01\x32\x12\x0e\n\x06offset\x18\x02 \x03(\r\"\xc3\x07\n\rDataParameter\x12\x0e\n\x06source\x18\x01 \x01(\t\x12\x15\n\nbatch_size\x18\x04 \x01(\r:\x01\x31\x12\x14\n\trand_skip\x18\x07 \x01(\r:\x01\x30\x12\x31\n\x07\x62\x61\x63kend\x18\x08 \x01(\x0e\x32\x17.caffe.DataParameter.DB:\x07LEVELDB\x12\x10\n\x05scale\x18\x02 \x01(\x02:\x01\x31\x12\x11\n\tmean_file\x18\x03 \x01(\t\x12\x14\n\tcrop_size\x18\x05 \x01(\r:\x01\x30\x12\x15\n\x06mirror\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\"\n\x13\x66orce_encoded_color\x18\t \x01(\x08:\x05\x66\x61lse\x12\x13\n\x08prefetch\x18\n \x01(\r:\x01\x34\x12\x1f\n\x13\x64isk_reader_threads\x18\xa1\x1f \x01(\r:\x01\x31\x12\"\n\x12huge_video_dataset\x18\xd8\x36 \x01(\x08:\x05\x66\x61lse\x12\x1a\n\rlimit_samples\x18\xd9\x36 \x01(\x05:\x02-1\x12\x1a\n\x11preselection_file\x18\xb9\x17 \x01(\t\x12\x1b\n\x12preselection_label\x18\xba\x17 \x01(\x05\x12\x17\n\x0brange_start\x18\xbb\x17 \x01(\x05:\x01\x30\x12\x16\n\trange_end\x18\xbc\x17 \x01(\x05:\x02-1\x12\x1c\n\x0crand_permute\x18\xbd\x17 \x01(\x08:\x05\x66\x61lse\x12Y\n\x12rand_permute_order\x18\xbe\x17 \x01(\x0e\x32\".caffe.DataParameter.RANDPERMORDER:\x18\x46IRST_PERMUTE_THEN_RANGE\x12\x1d\n\x11rand_permute_seed\x18\xbf\x17 \x01(\r:\x01\x30\x12\x14\n\x0bslice_point\x18\xc0\x17 \x03(\r\x12\x37\n\x08\x65ncoding\x18\xc1\x17 \x03(\x0e\x32$.caffe.DataParameter.CHANNELENCODING\x12\x17\n\x07verbose\x18\xc2\x17 \x01(\x08:\x05\x66\x61lse\x12\x11\n\x08subtract\x18\xc3\x17 \x03(\x02\x12\x1e\n\x12permute_every_iter\x18\xc4\x17 \x01(\r:\x01\x30\x12\x16\n\nblock_size\x18\xc5\x17 \x01(\r:\x01\x30\"\x1b\n\x02\x44\x42\x12\x0b\n\x07LEVELDB\x10\x00\x12\x08\n\x04LMDB\x10\x01\"7\n\x0f\x43HANNELENCODING\x12\t\n\x05UINT8\x10\x01\x12\x0e\n\nUINT16FLOW\x10\x02\x12\t\n\x05\x42OOL1\x10\x03\"K\n\rRANDPERMORDER\x12\x1c\n\x18\x46IRST_PERMUTE_THEN_RANGE\x10\x00\x12\x1c\n\x18\x46IRST_RANGE_THEN_PERMUTE\x10\x01\".\n\x10\x44ropoutParameter\x12\x1a\n\rdropout_ratio\x18\x01 \x01(\x02:\x03\x30.5\"\xa0\x01\n\x12\x44ummyDataParameter\x12+\n\x0b\x64\x61ta_filler\x18\x01 \x03(\x0b\x32\x16.caffe.FillerParameter\x12\x1f\n\x05shape\x18\x06 \x03(\x0b\x32\x10.caffe.BlobShape\x12\x0b\n\x03num\x18\x02 \x03(\r\x12\x10\n\x08\x63hannels\x18\x03 \x03(\r\x12\x0e\n\x06height\x18\x04 \x03(\r\x12\r\n\x05width\x18\x05 \x03(\r\"\xa5\x01\n\x10\x45ltwiseParameter\x12\x39\n\toperation\x18\x01 \x01(\x0e\x32!.caffe.EltwiseParameter.EltwiseOp:\x03SUM\x12\r\n\x05\x63oeff\x18\x02 \x03(\x02\x12\x1e\n\x10stable_prod_grad\x18\x03 \x01(\x08:\x04true\"\'\n\tEltwiseOp\x12\x08\n\x04PROD\x10\x00\x12\x07\n\x03SUM\x10\x01\x12\x07\n\x03MAX\x10\x02\" \n\x0c\x45LUParameter\x12\x10\n\x05\x61lpha\x18\x01 \x01(\x02:\x01\x31\"\xac\x01\n\x0e\x45mbedParameter\x12\x12\n\nnum_output\x18\x01 \x01(\r\x12\x11\n\tinput_dim\x18\x02 \x01(\r\x12\x17\n\tbias_term\x18\x03 \x01(\x08:\x04true\x12-\n\rweight_filler\x18\x04 \x01(\x0b\x32\x16.caffe.FillerParameter\x12+\n\x0b\x62ias_filler\x18\x05 \x01(\x0b\x32\x16.caffe.FillerParameter\"D\n\x0c\x45xpParameter\x12\x10\n\x04\x62\x61se\x18\x01 \x01(\x02:\x02-1\x12\x10\n\x05scale\x18\x02 \x01(\x02:\x01\x31\x12\x10\n\x05shift\x18\x03 \x01(\x02:\x01\x30\"G\n\x0f\x45xpMaxParameter\x12\x10\n\x04\x62\x61se\x18\x01 \x01(\x02:\x02-1\x12\x10\n\x05scale\x18\x02 \x01(\x02:\x01\x31\x12\x10\n\x05shift\x18\x03 \x01(\x02:\x01\x30\"9\n\x10\x46lattenParameter\x12\x0f\n\x04\x61xis\x18\x01 \x01(\x05:\x01\x31\x12\x14\n\x08\x65nd_axis\x18\x02 \x01(\x05:\x02-1\"O\n\x11HDF5DataParameter\x12\x0e\n\x06source\x18\x01 \x01(\t\x12\x12\n\nbatch_size\x18\x02 \x01(\r\x12\x16\n\x07shuffle\x18\x03 \x01(\x08:\x05\x66\x61lse\"(\n\x13HDF5OutputParameter\x12\x11\n\tfile_name\x18\x01 \x01(\t\"^\n\x12HingeLossParameter\x12\x30\n\x04norm\x18\x01 \x01(\x0e\x32\x1e.caffe.HingeLossParameter.Norm:\x02L1\"\x16\n\x04Norm\x12\x06\n\x02L1\x10\x01\x12\x06\n\x02L2\x10\x02\"\x97\x02\n\x12ImageDataParameter\x12\x0e\n\x06source\x18\x01 \x01(\t\x12\x15\n\nbatch_size\x18\x04 \x01(\r:\x01\x31\x12\x14\n\trand_skip\x18\x07 \x01(\r:\x01\x30\x12\x16\n\x07shuffle\x18\x08 \x01(\x08:\x05\x66\x61lse\x12\x15\n\nnew_height\x18\t \x01(\r:\x01\x30\x12\x14\n\tnew_width\x18\n \x01(\r:\x01\x30\x12\x16\n\x08is_color\x18\x0b \x01(\x08:\x04true\x12\x10\n\x05scale\x18\x02 \x01(\x02:\x01\x31\x12\x11\n\tmean_file\x18\x03 \x01(\t\x12\x14\n\tcrop_size\x18\x05 \x01(\r:\x01\x30\x12\x15\n\x06mirror\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x15\n\x0broot_folder\x18\x0c \x01(\t:\x00\"\'\n\x15InfogainLossParameter\x12\x0e\n\x06source\x18\x01 \x01(\t\"\xcb\x01\n\x15InnerProductParameter\x12\x12\n\nnum_output\x18\x01 \x01(\r\x12\x17\n\tbias_term\x18\x02 \x01(\x08:\x04true\x12-\n\rweight_filler\x18\x03 \x01(\x0b\x32\x16.caffe.FillerParameter\x12+\n\x0b\x62ias_filler\x18\x04 \x01(\x0b\x32\x16.caffe.FillerParameter\x12\x0f\n\x04\x61xis\x18\x05 \x01(\x05:\x01\x31\x12\x18\n\ttranspose\x18\x06 \x01(\x08:\x05\x66\x61lse\"1\n\x0eInputParameter\x12\x1f\n\x05shape\x18\x01 \x03(\x0b\x32\x10.caffe.BlobShape\"D\n\x0cLogParameter\x12\x10\n\x04\x62\x61se\x18\x01 \x01(\x02:\x02-1\x12\x10\n\x05scale\x18\x02 \x01(\x02:\x01\x31\x12\x10\n\x05shift\x18\x03 \x01(\x02:\x01\x30\"\xca\x02\n\x0cLRNParameter\x12\x15\n\nlocal_size\x18\x01 \x01(\r:\x01\x35\x12\x10\n\x05\x61lpha\x18\x02 \x01(\x02:\x01\x31\x12\x12\n\x04\x62\x65ta\x18\x03 \x01(\x02:\x04\x30.75\x12\x44\n\x0bnorm_region\x18\x04 \x01(\x0e\x32\x1e.caffe.LRNParameter.NormRegion:\x0f\x41\x43ROSS_CHANNELS\x12\x0c\n\x01k\x18\x05 \x01(\x02:\x01\x31\x12\x33\n\x06\x65ngine\x18\x06 \x01(\x0e\x32\x1a.caffe.LRNParameter.Engine:\x07\x44\x45\x46\x41ULT\x12\x10\n\x05shift\x18\x07 \x01(\x02:\x01\x31\"5\n\nNormRegion\x12\x13\n\x0f\x41\x43ROSS_CHANNELS\x10\x00\x12\x12\n\x0eWITHIN_CHANNEL\x10\x01\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"Z\n\x13MemoryDataParameter\x12\x12\n\nbatch_size\x18\x01 \x01(\r\x12\x10\n\x08\x63hannels\x18\x02 \x01(\r\x12\x0e\n\x06height\x18\x03 \x01(\r\x12\r\n\x05width\x18\x04 \x01(\r\"d\n\x0cMVNParameter\x12 \n\x12normalize_variance\x18\x01 \x01(\x08:\x04true\x12\x1e\n\x0f\x61\x63ross_channels\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x12\n\x03\x65ps\x18\x03 \x01(\x02:\x05\x31\x65-09\"5\n\x12ParameterParameter\x12\x1f\n\x05shape\x18\x01 \x01(\x0b\x32\x10.caffe.BlobShape\"\xa2\x03\n\x10PoolingParameter\x12\x35\n\x04pool\x18\x01 \x01(\x0e\x32\".caffe.PoolingParameter.PoolMethod:\x03MAX\x12\x0e\n\x03pad\x18\x04 \x01(\r:\x01\x30\x12\x10\n\x05pad_h\x18\t \x01(\r:\x01\x30\x12\x10\n\x05pad_w\x18\n \x01(\r:\x01\x30\x12\x13\n\x0bkernel_size\x18\x02 \x01(\r\x12\x10\n\x08kernel_h\x18\x05 \x01(\r\x12\x10\n\x08kernel_w\x18\x06 \x01(\r\x12\x11\n\x06stride\x18\x03 \x01(\r:\x01\x31\x12\x10\n\x08stride_h\x18\x07 \x01(\r\x12\x10\n\x08stride_w\x18\x08 \x01(\r\x12\x37\n\x06\x65ngine\x18\x0b \x01(\x0e\x32\x1e.caffe.PoolingParameter.Engine:\x07\x44\x45\x46\x41ULT\x12\x1d\n\x0eglobal_pooling\x18\x0c \x01(\x08:\x05\x66\x61lse\".\n\nPoolMethod\x12\x07\n\x03MAX\x10\x00\x12\x07\n\x03\x41VE\x10\x01\x12\x0e\n\nSTOCHASTIC\x10\x02\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"F\n\x0ePowerParameter\x12\x10\n\x05power\x18\x01 \x01(\x02:\x01\x31\x12\x10\n\x05scale\x18\x02 \x01(\x02:\x01\x31\x12\x10\n\x05shift\x18\x03 \x01(\x02:\x01\x30\"\x14\n\x12NegSquareParameter\"g\n\x0fPythonParameter\x12\x0e\n\x06module\x18\x01 \x01(\t\x12\r\n\x05layer\x18\x02 \x01(\t\x12\x13\n\tparam_str\x18\x03 \x01(\t:\x00\x12 \n\x11share_in_parallel\x18\x04 \x01(\x08:\x05\x66\x61lse\"\xc0\x01\n\x12RecurrentParameter\x12\x15\n\nnum_output\x18\x01 \x01(\r:\x01\x30\x12-\n\rweight_filler\x18\x02 \x01(\x0b\x32\x16.caffe.FillerParameter\x12+\n\x0b\x62ias_filler\x18\x03 \x01(\x0b\x32\x16.caffe.FillerParameter\x12\x19\n\ndebug_info\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\x1c\n\rexpose_hidden\x18\x05 \x01(\x08:\x05\x66\x61lse\"\xad\x01\n\x12ReductionParameter\x12=\n\toperation\x18\x01 \x01(\x0e\x32%.caffe.ReductionParameter.ReductionOp:\x03SUM\x12\x0f\n\x04\x61xis\x18\x02 \x01(\x05:\x01\x30\x12\x10\n\x05\x63oeff\x18\x03 \x01(\x02:\x01\x31\"5\n\x0bReductionOp\x12\x07\n\x03SUM\x10\x01\x12\x08\n\x04\x41SUM\x10\x02\x12\t\n\x05SUMSQ\x10\x03\x12\x08\n\x04MEAN\x10\x04\"\x8d\x01\n\rReLUParameter\x12\x19\n\x0enegative_slope\x18\x01 \x01(\x02:\x01\x30\x12\x34\n\x06\x65ngine\x18\x02 \x01(\x0e\x32\x1b.caffe.ReLUParameter.Engine:\x07\x44\x45\x46\x41ULT\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"Z\n\x10ReshapeParameter\x12\x1f\n\x05shape\x18\x01 \x01(\x0b\x32\x10.caffe.BlobShape\x12\x0f\n\x04\x61xis\x18\x02 \x01(\x05:\x01\x30\x12\x14\n\x08num_axes\x18\x03 \x01(\x05:\x02-1\"\xa5\x01\n\x0eScaleParameter\x12\x0f\n\x04\x61xis\x18\x01 \x01(\x05:\x01\x31\x12\x13\n\x08num_axes\x18\x02 \x01(\x05:\x01\x31\x12&\n\x06\x66iller\x18\x03 \x01(\x0b\x32\x16.caffe.FillerParameter\x12\x18\n\tbias_term\x18\x04 \x01(\x08:\x05\x66\x61lse\x12+\n\x0b\x62ias_filler\x18\x05 \x01(\x0b\x32\x16.caffe.FillerParameter\"x\n\x10SigmoidParameter\x12\x37\n\x06\x65ngine\x18\x01 \x01(\x0e\x32\x1e.caffe.SigmoidParameter.Engine:\x07\x44\x45\x46\x41ULT\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"L\n\x0eSliceParameter\x12\x0f\n\x04\x61xis\x18\x03 \x01(\x05:\x01\x31\x12\x13\n\x0bslice_point\x18\x02 \x03(\r\x12\x14\n\tslice_dim\x18\x01 \x01(\r:\x01\x31\"\x89\x01\n\x10SoftmaxParameter\x12\x37\n\x06\x65ngine\x18\x01 \x01(\x0e\x32\x1e.caffe.SoftmaxParameter.Engine:\x07\x44\x45\x46\x41ULT\x12\x0f\n\x04\x61xis\x18\x02 \x01(\x05:\x01\x31\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"r\n\rTanHParameter\x12\x34\n\x06\x65ngine\x18\x01 \x01(\x0e\x32\x1b.caffe.TanHParameter.Engine:\x07\x44\x45\x46\x41ULT\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"/\n\rTileParameter\x12\x0f\n\x04\x61xis\x18\x01 \x01(\x05:\x01\x31\x12\r\n\x05tiles\x18\x02 \x01(\x05\"*\n\x12ThresholdParameter\x12\x14\n\tthreshold\x18\x01 \x01(\x02:\x01\x30\"\xc1\x02\n\x13WindowDataParameter\x12\x0e\n\x06source\x18\x01 \x01(\t\x12\x10\n\x05scale\x18\x02 \x01(\x02:\x01\x31\x12\x11\n\tmean_file\x18\x03 \x01(\t\x12\x12\n\nbatch_size\x18\x04 \x01(\r\x12\x14\n\tcrop_size\x18\x05 \x01(\r:\x01\x30\x12\x15\n\x06mirror\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x19\n\x0c\x66g_threshold\x18\x07 \x01(\x02:\x03\x30.5\x12\x19\n\x0c\x62g_threshold\x18\x08 \x01(\x02:\x03\x30.5\x12\x19\n\x0b\x66g_fraction\x18\t \x01(\x02:\x04\x30.25\x12\x16\n\x0b\x63ontext_pad\x18\n \x01(\r:\x01\x30\x12\x17\n\tcrop_mode\x18\x0b \x01(\t:\x04warp\x12\x1b\n\x0c\x63\x61\x63he_images\x18\x0c \x01(\x08:\x05\x66\x61lse\x12\x15\n\x0broot_folder\x18\r \x01(\t:\x00\"\xeb\x01\n\x0cSPPParameter\x12\x16\n\x0epyramid_height\x18\x01 \x01(\r\x12\x31\n\x04pool\x18\x02 \x01(\x0e\x32\x1e.caffe.SPPParameter.PoolMethod:\x03MAX\x12\x33\n\x06\x65ngine\x18\x06 \x01(\x0e\x32\x1a.caffe.SPPParameter.Engine:\x07\x44\x45\x46\x41ULT\".\n\nPoolMethod\x12\x07\n\x03MAX\x10\x00\x12\x07\n\x03\x41VE\x10\x01\x12\x0e\n\nSTOCHASTIC\x10\x02\"+\n\x06\x45ngine\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x43\x41\x46\x46\x45\x10\x01\x12\t\n\x05\x43UDNN\x10\x02\"\xe0\x13\n\x10V1LayerParameter\x12\x0e\n\x06\x62ottom\x18\x02 \x03(\t\x12\x0b\n\x03top\x18\x03 \x03(\t\x12\x0c\n\x04name\x18\x04 \x01(\t\x12$\n\x07include\x18 \x03(\x0b\x32\x13.caffe.NetStateRule\x12$\n\x07\x65xclude\x18! \x03(\x0b\x32\x13.caffe.NetStateRule\x12/\n\x04type\x18\x05 \x01(\x0e\x32!.caffe.V1LayerParameter.LayerType\x12\x1f\n\x05\x62lobs\x18\x06 \x03(\x0b\x32\x10.caffe.BlobProto\x12\x0e\n\x05param\x18\xe9\x07 \x03(\t\x12>\n\x0f\x62lob_share_mode\x18\xea\x07 \x03(\x0e\x32$.caffe.V1LayerParameter.DimCheckMode\x12\x10\n\x08\x62lobs_lr\x18\x07 \x03(\x02\x12\x14\n\x0cweight_decay\x18\x08 \x03(\x02\x12\x13\n\x0bloss_weight\x18# \x03(\x02\x12\x30\n\x0e\x61\x63\x63uracy_param\x18\x1b \x01(\x0b\x32\x18.caffe.AccuracyParameter\x12,\n\x0c\x61rgmax_param\x18\x17 \x01(\x0b\x32\x16.caffe.ArgMaxParameter\x12,\n\x0c\x63oncat_param\x18\t \x01(\x0b\x32\x16.caffe.ConcatParameter\x12?\n\x16\x63ontrastive_loss_param\x18( \x01(\x0b\x32\x1f.caffe.ContrastiveLossParameter\x12\x36\n\x11\x63onvolution_param\x18\n \x01(\x0b\x32\x1b.caffe.ConvolutionParameter\x12(\n\ndata_param\x18\x0b \x01(\x0b\x32\x14.caffe.DataParameter\x12.\n\rdropout_param\x18\x0c \x01(\x0b\x32\x17.caffe.DropoutParameter\x12\x33\n\x10\x64ummy_data_param\x18\x1a \x01(\x0b\x32\x19.caffe.DummyDataParameter\x12.\n\reltwise_param\x18\x18 \x01(\x0b\x32\x17.caffe.EltwiseParameter\x12&\n\texp_param\x18) \x01(\x0b\x32\x13.caffe.ExpParameter\x12\x31\n\x0fhdf5_data_param\x18\r \x01(\x0b\x32\x18.caffe.HDF5DataParameter\x12\x35\n\x11hdf5_output_param\x18\x0e \x01(\x0b\x32\x1a.caffe.HDF5OutputParameter\x12\x33\n\x10hinge_loss_param\x18\x1d \x01(\x0b\x32\x19.caffe.HingeLossParameter\x12\x33\n\x10image_data_param\x18\x0f \x01(\x0b\x32\x19.caffe.ImageDataParameter\x12\x39\n\x13infogain_loss_param\x18\x10 \x01(\x0b\x32\x1c.caffe.InfogainLossParameter\x12\x39\n\x13inner_product_param\x18\x11 \x01(\x0b\x32\x1c.caffe.InnerProductParameter\x12&\n\tlrn_param\x18\x12 \x01(\x0b\x32\x13.caffe.LRNParameter\x12\x35\n\x11memory_data_param\x18\x16 \x01(\x0b\x32\x1a.caffe.MemoryDataParameter\x12&\n\tmvn_param\x18\" \x01(\x0b\x32\x13.caffe.MVNParameter\x12.\n\rpooling_param\x18\x13 \x01(\x0b\x32\x17.caffe.PoolingParameter\x12*\n\x0bpower_param\x18\x15 \x01(\x0b\x32\x15.caffe.PowerParameter\x12(\n\nrelu_param\x18\x1e \x01(\x0b\x32\x14.caffe.ReLUParameter\x12.\n\rsigmoid_param\x18& \x01(\x0b\x32\x17.caffe.SigmoidParameter\x12.\n\rsoftmax_param\x18\' \x01(\x0b\x32\x17.caffe.SoftmaxParameter\x12*\n\x0bslice_param\x18\x1f \x01(\x0b\x32\x15.caffe.SliceParameter\x12(\n\ntanh_param\x18% \x01(\x0b\x32\x14.caffe.TanHParameter\x12\x32\n\x0fthreshold_param\x18\x19 \x01(\x0b\x32\x19.caffe.ThresholdParameter\x12\x35\n\x11window_data_param\x18\x14 \x01(\x0b\x32\x1a.caffe.WindowDataParameter\x12\x37\n\x0ftransform_param\x18$ \x01(\x0b\x32\x1e.caffe.TransformationParameter\x12(\n\nloss_param\x18* \x01(\x0b\x32\x14.caffe.LossParameter\x12&\n\x05layer\x18\x01 \x01(\x0b\x32\x17.caffe.V0LayerParameter\"\xd8\x04\n\tLayerType\x12\x08\n\x04NONE\x10\x00\x12\n\n\x06\x41\x42SVAL\x10#\x12\x0c\n\x08\x41\x43\x43URACY\x10\x01\x12\n\n\x06\x41RGMAX\x10\x1e\x12\x08\n\x04\x42NLL\x10\x02\x12\n\n\x06\x43ONCAT\x10\x03\x12\x14\n\x10\x43ONTRASTIVE_LOSS\x10%\x12\x0f\n\x0b\x43ONVOLUTION\x10\x04\x12\x08\n\x04\x44\x41TA\x10\x05\x12\x11\n\rDECONVOLUTION\x10\'\x12\x0b\n\x07\x44ROPOUT\x10\x06\x12\x0e\n\nDUMMY_DATA\x10 \x12\x12\n\x0e\x45UCLIDEAN_LOSS\x10\x07\x12\x0b\n\x07\x45LTWISE\x10\x19\x12\x07\n\x03\x45XP\x10&\x12\x0b\n\x07\x46LATTEN\x10\x08\x12\r\n\tHDF5_DATA\x10\t\x12\x0f\n\x0bHDF5_OUTPUT\x10\n\x12\x0e\n\nHINGE_LOSS\x10\x1c\x12\n\n\x06IM2COL\x10\x0b\x12\x0e\n\nIMAGE_DATA\x10\x0c\x12\x11\n\rINFOGAIN_LOSS\x10\r\x12\x11\n\rINNER_PRODUCT\x10\x0e\x12\x07\n\x03LRN\x10\x0f\x12\x0f\n\x0bMEMORY_DATA\x10\x1d\x12\x1d\n\x19MULTINOMIAL_LOGISTIC_LOSS\x10\x10\x12\x07\n\x03MVN\x10\"\x12\x0b\n\x07POOLING\x10\x11\x12\t\n\x05POWER\x10\x1a\x12\x08\n\x04RELU\x10\x12\x12\x0b\n\x07SIGMOID\x10\x13\x12\x1e\n\x1aSIGMOID_CROSS_ENTROPY_LOSS\x10\x1b\x12\x0b\n\x07SILENCE\x10$\x12\x0b\n\x07SOFTMAX\x10\x14\x12\x10\n\x0cSOFTMAX_LOSS\x10\x15\x12\t\n\x05SPLIT\x10\x16\x12\t\n\x05SLICE\x10!\x12\x08\n\x04TANH\x10\x17\x12\x0f\n\x0bWINDOW_DATA\x10\x18\x12\r\n\tTHRESHOLD\x10\x1f\"*\n\x0c\x44imCheckMode\x12\n\n\x06STRICT\x10\x00\x12\x0e\n\nPERMISSIVE\x10\x01\"\xfd\x07\n\x10V0LayerParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\x12\x12\n\nnum_output\x18\x03 \x01(\r\x12\x16\n\x08\x62iasterm\x18\x04 \x01(\x08:\x04true\x12-\n\rweight_filler\x18\x05 \x01(\x0b\x32\x16.caffe.FillerParameter\x12+\n\x0b\x62ias_filler\x18\x06 \x01(\x0b\x32\x16.caffe.FillerParameter\x12\x0e\n\x03pad\x18\x07 \x01(\r:\x01\x30\x12\x12\n\nkernelsize\x18\x08 \x01(\r\x12\x10\n\x05group\x18\t \x01(\r:\x01\x31\x12\x11\n\x06stride\x18\n \x01(\r:\x01\x31\x12\x35\n\x04pool\x18\x0b \x01(\x0e\x32\".caffe.V0LayerParameter.PoolMethod:\x03MAX\x12\x1a\n\rdropout_ratio\x18\x0c \x01(\x02:\x03\x30.5\x12\x15\n\nlocal_size\x18\r \x01(\r:\x01\x35\x12\x10\n\x05\x61lpha\x18\x0e \x01(\x02:\x01\x31\x12\x12\n\x04\x62\x65ta\x18\x0f \x01(\x02:\x04\x30.75\x12\x0c\n\x01k\x18\x16 \x01(\x02:\x01\x31\x12\x0e\n\x06source\x18\x10 \x01(\t\x12\x10\n\x05scale\x18\x11 \x01(\x02:\x01\x31\x12\x10\n\x08meanfile\x18\x12 \x01(\t\x12\x11\n\tbatchsize\x18\x13 \x01(\r\x12\x13\n\x08\x63ropsize\x18\x14 \x01(\r:\x01\x30\x12\x15\n\x06mirror\x18\x15 \x01(\x08:\x05\x66\x61lse\x12\x1f\n\x05\x62lobs\x18\x32 \x03(\x0b\x32\x10.caffe.BlobProto\x12\x10\n\x08\x62lobs_lr\x18\x33 \x03(\x02\x12\x14\n\x0cweight_decay\x18\x34 \x03(\x02\x12\x14\n\trand_skip\x18\x35 \x01(\r:\x01\x30\x12\x1d\n\x10\x64\x65t_fg_threshold\x18\x36 \x01(\x02:\x03\x30.5\x12\x1d\n\x10\x64\x65t_bg_threshold\x18\x37 \x01(\x02:\x03\x30.5\x12\x1d\n\x0f\x64\x65t_fg_fraction\x18\x38 \x01(\x02:\x04\x30.25\x12\x1a\n\x0f\x64\x65t_context_pad\x18: \x01(\r:\x01\x30\x12\x1b\n\rdet_crop_mode\x18; \x01(\t:\x04warp\x12\x12\n\x07new_num\x18< \x01(\x05:\x01\x30\x12\x17\n\x0cnew_channels\x18= \x01(\x05:\x01\x30\x12\x15\n\nnew_height\x18> \x01(\x05:\x01\x30\x12\x14\n\tnew_width\x18? \x01(\x05:\x01\x30\x12\x1d\n\x0eshuffle_images\x18@ \x01(\x08:\x05\x66\x61lse\x12\x15\n\nconcat_dim\x18\x41 \x01(\r:\x01\x31\x12\x36\n\x11hdf5_output_param\x18\xe9\x07 \x01(\x0b\x32\x1a.caffe.HDF5OutputParameter\".\n\nPoolMethod\x12\x07\n\x03MAX\x10\x00\x12\x07\n\x03\x41VE\x10\x01\x12\x0e\n\nSTOCHASTIC\x10\x02\"W\n\x0ePReLUParameter\x12&\n\x06\x66iller\x18\x01 \x01(\x0b\x32\x16.caffe.FillerParameter\x12\x1d\n\x0e\x63hannel_shared\x18\x02 \x01(\x08:\x05\x66\x61lse*\x1c\n\x05Phase\x12\t\n\x05TRAIN\x10\x00\x12\x08\n\x04TEST\x10\x01') + +_PHASE = _descriptor.EnumDescriptor( + name='Phase', + full_name='caffe.Phase', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='TRAIN', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='TEST', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=21335, + serialized_end=21363, +) + +Phase = enum_type_wrapper.EnumTypeWrapper(_PHASE) +TRAIN = 0 +TEST = 1 + + +_FILLERPARAMETER_VARIANCENORM = _descriptor.EnumDescriptor( + name='VarianceNorm', + full_name='caffe.FillerParameter.VarianceNorm', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='FAN_IN', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='FAN_OUT', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='AVERAGE', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=690, + serialized_end=742, +) + +_SOLVERPARAMETER_SNAPSHOTFORMAT = _descriptor.EnumDescriptor( + name='SnapshotFormat', + full_name='caffe.SolverParameter.SnapshotFormat', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='HDF5', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='BINARYPROTO', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=2164, + serialized_end=2207, +) + +_SOLVERPARAMETER_SOLVERMODE = _descriptor.EnumDescriptor( + name='SolverMode', + full_name='caffe.SolverParameter.SolverMode', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='CPU', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='GPU', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=2209, + serialized_end=2239, +) + +_SOLVERPARAMETER_SOLVERTYPE = _descriptor.EnumDescriptor( + name='SolverType', + full_name='caffe.SolverParameter.SolverType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='SGD', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='NESTEROV', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ADAGRAD', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='RMSPROP', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ADADELTA', index=4, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ADAM', index=5, number=5, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=2241, + serialized_end=2326, +) + +_PARAMSPEC_DIMCHECKMODE = _descriptor.EnumDescriptor( + name='DimCheckMode', + full_name='caffe.ParamSpec.DimCheckMode', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='STRICT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='PERMISSIVE', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=2757, + serialized_end=2799, +) + +_CORRELATIONPARAMETER_CORRELATIONTYPE = _descriptor.EnumDescriptor( + name='CorrelationType', + full_name='caffe.CorrelationParameter.CorrelationType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='MULTIPLY', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SUBTRACT', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=9727, + serialized_end=9772, +) + +_RESAMPLEPARAMETER_RESAMPLETYPE = _descriptor.EnumDescriptor( + name='ResampleType', + full_name='caffe.ResampleParameter.ResampleType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='NEAREST', index=0, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='LINEAR', index=1, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUBIC', index=2, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='AREA', index=3, number=4, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=10164, + serialized_end=10224, +) + +_MEANPARAMETER_MEANOPERATION = _descriptor.EnumDescriptor( + name='MeanOperation', + full_name='caffe.MeanParameter.MeanOperation', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='ADD', index=0, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SUBTRACT', index=1, number=4, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=10400, + serialized_end=10438, +) + +_LOSSPARAMETER_NORMALIZATIONMODE = _descriptor.EnumDescriptor( + name='NormalizationMode', + full_name='caffe.LossParameter.NormalizationMode', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='FULL', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='VALID', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='BATCH_SIZE', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='NONE', index=3, number=3, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=10852, + serialized_end=10918, +) + +_CONVOLUTIONPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.ConvolutionParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_DATAPARAMETER_DB = _descriptor.EnumDescriptor( + name='DB', + full_name='caffe.DataParameter.DB', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='LEVELDB', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='LMDB', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=12781, + serialized_end=12808, +) + +_DATAPARAMETER_CHANNELENCODING = _descriptor.EnumDescriptor( + name='CHANNELENCODING', + full_name='caffe.DataParameter.CHANNELENCODING', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UINT8', index=0, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='UINT16FLOW', index=1, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='BOOL1', index=2, number=3, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=12810, + serialized_end=12865, +) + +_DATAPARAMETER_RANDPERMORDER = _descriptor.EnumDescriptor( + name='RANDPERMORDER', + full_name='caffe.DataParameter.RANDPERMORDER', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='FIRST_PERMUTE_THEN_RANGE', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='FIRST_RANGE_THEN_PERMUTE', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=12867, + serialized_end=12942, +) + +_ELTWISEPARAMETER_ELTWISEOP = _descriptor.EnumDescriptor( + name='EltwiseOp', + full_name='caffe.EltwiseParameter.EltwiseOp', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='PROD', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SUM', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='MAX', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=13282, + serialized_end=13321, +) + +_HINGELOSSPARAMETER_NORM = _descriptor.EnumDescriptor( + name='Norm', + full_name='caffe.HingeLossParameter.Norm', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='L1', index=0, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='L2', index=1, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=13929, + serialized_end=13951, +) + +_LRNPARAMETER_NORMREGION = _descriptor.EnumDescriptor( + name='NormRegion', + full_name='caffe.LRNParameter.NormRegion', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='ACROSS_CHANNELS', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='WITHIN_CHANNEL', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=14836, + serialized_end=14889, +) + +_LRNPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.LRNParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_POOLINGPARAMETER_POOLMETHOD = _descriptor.EnumDescriptor( + name='PoolMethod', + full_name='caffe.PoolingParameter.PoolMethod', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='MAX', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='AVE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='STOCHASTIC', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=15513, + serialized_end=15559, +) + +_POOLINGPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.PoolingParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_REDUCTIONPARAMETER_REDUCTIONOP = _descriptor.EnumDescriptor( + name='ReductionOp', + full_name='caffe.ReductionParameter.ReductionOp', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='SUM', index=0, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ASUM', index=1, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SUMSQ', index=2, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='MEAN', index=3, number=4, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=16121, + serialized_end=16174, +) + +_RELUPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.ReLUParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_SIGMOIDPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.SigmoidParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_SOFTMAXPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.SoftmaxParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_TANHPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.TanHParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_SPPPARAMETER_POOLMETHOD = _descriptor.EnumDescriptor( + name='PoolMethod', + full_name='caffe.SPPParameter.PoolMethod', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='MAX', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='AVE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='STOCHASTIC', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=15513, + serialized_end=15559, +) + +_SPPPARAMETER_ENGINE = _descriptor.EnumDescriptor( + name='Engine', + full_name='caffe.SPPParameter.Engine', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CAFFE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CUDNN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=11883, + serialized_end=11926, +) + +_V1LAYERPARAMETER_LAYERTYPE = _descriptor.EnumDescriptor( + name='LayerType', + full_name='caffe.V1LayerParameter.LayerType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='NONE', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ABSVAL', index=1, number=35, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ACCURACY', index=2, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ARGMAX', index=3, number=30, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='BNLL', index=4, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CONCAT', index=5, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CONTRASTIVE_LOSS', index=6, number=37, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CONVOLUTION', index=7, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DATA', index=8, number=5, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DECONVOLUTION', index=9, number=39, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DROPOUT', index=10, number=6, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DUMMY_DATA', index=11, number=32, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='EUCLIDEAN_LOSS', index=12, number=7, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ELTWISE', index=13, number=25, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='EXP', index=14, number=38, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='FLATTEN', index=15, number=8, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='HDF5_DATA', index=16, number=9, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='HDF5_OUTPUT', index=17, number=10, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='HINGE_LOSS', index=18, number=28, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='IM2COL', index=19, number=11, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='IMAGE_DATA', index=20, number=12, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INFOGAIN_LOSS', index=21, number=13, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INNER_PRODUCT', index=22, number=14, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='LRN', index=23, number=15, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='MEMORY_DATA', index=24, number=29, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='MULTINOMIAL_LOGISTIC_LOSS', index=25, number=16, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='MVN', index=26, number=34, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='POOLING', index=27, number=17, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='POWER', index=28, number=26, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='RELU', index=29, number=18, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SIGMOID', index=30, number=19, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SIGMOID_CROSS_ENTROPY_LOSS', index=31, number=27, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SILENCE', index=32, number=36, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SOFTMAX', index=33, number=20, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SOFTMAX_LOSS', index=34, number=21, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SPLIT', index=35, number=22, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SLICE', index=36, number=33, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='TANH', index=37, number=23, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='WINDOW_DATA', index=38, number=24, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='THRESHOLD', index=39, number=31, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=19576, + serialized_end=20176, +) + +_V1LAYERPARAMETER_DIMCHECKMODE = _descriptor.EnumDescriptor( + name='DimCheckMode', + full_name='caffe.V1LayerParameter.DimCheckMode', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='STRICT', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='PERMISSIVE', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=2757, + serialized_end=2799, +) + +_V0LAYERPARAMETER_POOLMETHOD = _descriptor.EnumDescriptor( + name='PoolMethod', + full_name='caffe.V0LayerParameter.PoolMethod', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='MAX', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='AVE', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='STOCHASTIC', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=15513, + serialized_end=15559, +) + + +_BLOBSHAPE = _descriptor.Descriptor( + name='BlobShape', + full_name='caffe.BlobShape', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='dim', full_name='caffe.BlobShape.dim', index=0, + number=1, type=3, cpp_type=2, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=_descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001')), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=22, + serialized_end=50, +) + + +_BLOBPROTO = _descriptor.Descriptor( + name='BlobProto', + full_name='caffe.BlobProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='shape', full_name='caffe.BlobProto.shape', index=0, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data', full_name='caffe.BlobProto.data', index=1, + number=5, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=_descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001')), + _descriptor.FieldDescriptor( + name='diff', full_name='caffe.BlobProto.diff', index=2, + number=6, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=_descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001')), + _descriptor.FieldDescriptor( + name='double_data', full_name='caffe.BlobProto.double_data', index=3, + number=8, type=1, cpp_type=5, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=_descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001')), + _descriptor.FieldDescriptor( + name='double_diff', full_name='caffe.BlobProto.double_diff', index=4, + number=9, type=1, cpp_type=5, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=_descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001')), + _descriptor.FieldDescriptor( + name='num', full_name='caffe.BlobProto.num', index=5, + number=1, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='channels', full_name='caffe.BlobProto.channels', index=6, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='height', full_name='caffe.BlobProto.height', index=7, + number=3, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='width', full_name='caffe.BlobProto.width', index=8, + number=4, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=53, + serialized_end=257, +) + + +_BLOBPROTOVECTOR = _descriptor.Descriptor( + name='BlobProtoVector', + full_name='caffe.BlobProtoVector', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='blobs', full_name='caffe.BlobProtoVector.blobs', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=259, + serialized_end=309, +) + + +_DATUM = _descriptor.Descriptor( + name='Datum', + full_name='caffe.Datum', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='channels', full_name='caffe.Datum.channels', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='height', full_name='caffe.Datum.height', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='width', full_name='caffe.Datum.width', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data', full_name='caffe.Datum.data', index=3, + number=4, type=12, cpp_type=9, label=1, + has_default_value=False, default_value="", + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='label', full_name='caffe.Datum.label', index=4, + number=5, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='float_data', full_name='caffe.Datum.float_data', index=5, + number=6, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='encoded', full_name='caffe.Datum.encoded', index=6, + number=7, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=312, + serialized_end=441, +) + + +_FILLERPARAMETER = _descriptor.Descriptor( + name='FillerParameter', + full_name='caffe.FillerParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='type', full_name='caffe.FillerParameter.type', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("constant", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='caffe.FillerParameter.value', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='min', full_name='caffe.FillerParameter.min', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max', full_name='caffe.FillerParameter.max', index=3, + number=4, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean', full_name='caffe.FillerParameter.mean', index=4, + number=5, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='std', full_name='caffe.FillerParameter.std', index=5, + number=6, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sparse', full_name='caffe.FillerParameter.sparse', index=6, + number=7, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='variance_norm', full_name='caffe.FillerParameter.variance_norm', index=7, + number=8, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='diag_val', full_name='caffe.FillerParameter.diag_val', index=8, + number=9, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='file', full_name='caffe.FillerParameter.file', index=9, + number=10, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _FILLERPARAMETER_VARIANCENORM, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=444, + serialized_end=742, +) + + +_NETPARAMETER = _descriptor.Descriptor( + name='NetParameter', + full_name='caffe.NetParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='caffe.NetParameter.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='input', full_name='caffe.NetParameter.input', index=1, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='input_shape', full_name='caffe.NetParameter.input_shape', index=2, + number=8, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='input_dim', full_name='caffe.NetParameter.input_dim', index=3, + number=4, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='force_backward', full_name='caffe.NetParameter.force_backward', index=4, + number=5, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='state', full_name='caffe.NetParameter.state', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='debug_info', full_name='caffe.NetParameter.debug_info', index=6, + number=7, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='layer', full_name='caffe.NetParameter.layer', index=7, + number=100, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='layers', full_name='caffe.NetParameter.layers', index=8, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=745, + serialized_end=1015, +) + + +_SOLVERPARAMETER = _descriptor.Descriptor( + name='SolverParameter', + full_name='caffe.SolverParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='net', full_name='caffe.SolverParameter.net', index=0, + number=24, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='net_param', full_name='caffe.SolverParameter.net_param', index=1, + number=25, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='train_net', full_name='caffe.SolverParameter.train_net', index=2, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='test_net', full_name='caffe.SolverParameter.test_net', index=3, + number=2, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='train_net_param', full_name='caffe.SolverParameter.train_net_param', index=4, + number=21, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='test_net_param', full_name='caffe.SolverParameter.test_net_param', index=5, + number=22, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='train_state', full_name='caffe.SolverParameter.train_state', index=6, + number=26, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='test_state', full_name='caffe.SolverParameter.test_state', index=7, + number=27, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='test_iter', full_name='caffe.SolverParameter.test_iter', index=8, + number=3, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='test_interval', full_name='caffe.SolverParameter.test_interval', index=9, + number=4, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='test_compute_loss', full_name='caffe.SolverParameter.test_compute_loss', index=10, + number=19, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='test_initialization', full_name='caffe.SolverParameter.test_initialization', index=11, + number=32, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='base_lr', full_name='caffe.SolverParameter.base_lr', index=12, + number=5, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='display', full_name='caffe.SolverParameter.display', index=13, + number=6, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='average_loss', full_name='caffe.SolverParameter.average_loss', index=14, + number=33, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_iter', full_name='caffe.SolverParameter.max_iter', index=15, + number=7, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='iter_size', full_name='caffe.SolverParameter.iter_size', index=16, + number=36, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lr_policy', full_name='caffe.SolverParameter.lr_policy', index=17, + number=8, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='gamma', full_name='caffe.SolverParameter.gamma', index=18, + number=9, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='power', full_name='caffe.SolverParameter.power', index=19, + number=10, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='momentum', full_name='caffe.SolverParameter.momentum', index=20, + number=11, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_decay', full_name='caffe.SolverParameter.weight_decay', index=21, + number=12, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='regularization_type', full_name='caffe.SolverParameter.regularization_type', index=22, + number=29, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("L2", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stepsize', full_name='caffe.SolverParameter.stepsize', index=23, + number=13, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stepvalue', full_name='caffe.SolverParameter.stepvalue', index=24, + number=34, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='clip_gradients', full_name='caffe.SolverParameter.clip_gradients', index=25, + number=35, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='snapshot', full_name='caffe.SolverParameter.snapshot', index=26, + number=14, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='snapshot_prefix', full_name='caffe.SolverParameter.snapshot_prefix', index=27, + number=15, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='snapshot_diff', full_name='caffe.SolverParameter.snapshot_diff', index=28, + number=16, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='snapshot_format', full_name='caffe.SolverParameter.snapshot_format', index=29, + number=37, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='solver_mode', full_name='caffe.SolverParameter.solver_mode', index=30, + number=17, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='device_id', full_name='caffe.SolverParameter.device_id', index=31, + number=18, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='random_seed', full_name='caffe.SolverParameter.random_seed', index=32, + number=20, type=3, cpp_type=2, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='type', full_name='caffe.SolverParameter.type', index=33, + number=40, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("SGD", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='delta', full_name='caffe.SolverParameter.delta', index=34, + number=31, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1e-08, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='momentum2', full_name='caffe.SolverParameter.momentum2', index=35, + number=39, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.999, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rms_decay', full_name='caffe.SolverParameter.rms_decay', index=36, + number=38, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='debug_info', full_name='caffe.SolverParameter.debug_info', index=37, + number=23, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='snapshot_after_train', full_name='caffe.SolverParameter.snapshot_after_train', index=38, + number=28, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='solver_type', full_name='caffe.SolverParameter.solver_type', index=39, + number=30, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _SOLVERPARAMETER_SNAPSHOTFORMAT, + _SOLVERPARAMETER_SOLVERMODE, + _SOLVERPARAMETER_SOLVERTYPE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=1018, + serialized_end=2326, +) + + +_SOLVERSTATE = _descriptor.Descriptor( + name='SolverState', + full_name='caffe.SolverState', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='iter', full_name='caffe.SolverState.iter', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='learned_net', full_name='caffe.SolverState.learned_net', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='history', full_name='caffe.SolverState.history', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='current_step', full_name='caffe.SolverState.current_step', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=2328, + serialized_end=2436, +) + + +_NETSTATE = _descriptor.Descriptor( + name='NetState', + full_name='caffe.NetState', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='phase', full_name='caffe.NetState.phase', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='level', full_name='caffe.NetState.level', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stage', full_name='caffe.NetState.stage', index=2, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=2438, + serialized_end=2516, +) + + +_NETSTATERULE = _descriptor.Descriptor( + name='NetStateRule', + full_name='caffe.NetStateRule', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='phase', full_name='caffe.NetStateRule.phase', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='min_level', full_name='caffe.NetStateRule.min_level', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_level', full_name='caffe.NetStateRule.max_level', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stage', full_name='caffe.NetStateRule.stage', index=3, + number=4, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='not_stage', full_name='caffe.NetStateRule.not_stage', index=4, + number=5, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=2518, + serialized_end=2633, +) + + +_PARAMSPEC = _descriptor.Descriptor( + name='ParamSpec', + full_name='caffe.ParamSpec', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='caffe.ParamSpec.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='share_mode', full_name='caffe.ParamSpec.share_mode', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lr_mult', full_name='caffe.ParamSpec.lr_mult', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='decay_mult', full_name='caffe.ParamSpec.decay_mult', index=3, + number=4, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _PARAMSPEC_DIMCHECKMODE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=2636, + serialized_end=2799, +) + + +_LAYERPARAMETER = _descriptor.Descriptor( + name='LayerParameter', + full_name='caffe.LayerParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='caffe.LayerParameter.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='type', full_name='caffe.LayerParameter.type', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bottom', full_name='caffe.LayerParameter.bottom', index=2, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='top', full_name='caffe.LayerParameter.top', index=3, + number=4, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='phase', full_name='caffe.LayerParameter.phase', index=4, + number=10, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='loss_weight', full_name='caffe.LayerParameter.loss_weight', index=5, + number=5, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='param', full_name='caffe.LayerParameter.param', index=6, + number=6, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='blobs', full_name='caffe.LayerParameter.blobs', index=7, + number=7, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='propagate_down', full_name='caffe.LayerParameter.propagate_down', index=8, + number=11, type=8, cpp_type=7, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='include', full_name='caffe.LayerParameter.include', index=9, + number=8, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='exclude', full_name='caffe.LayerParameter.exclude', index=10, + number=9, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transform_param', full_name='caffe.LayerParameter.transform_param', index=11, + number=100, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='loss_param', full_name='caffe.LayerParameter.loss_param', index=12, + number=101, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='accuracy_param', full_name='caffe.LayerParameter.accuracy_param', index=13, + number=102, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='argmax_param', full_name='caffe.LayerParameter.argmax_param', index=14, + number=103, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='batch_norm_param', full_name='caffe.LayerParameter.batch_norm_param', index=15, + number=139, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_param', full_name='caffe.LayerParameter.bias_param', index=16, + number=141, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='concat_param', full_name='caffe.LayerParameter.concat_param', index=17, + number=104, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='contrastive_loss_param', full_name='caffe.LayerParameter.contrastive_loss_param', index=18, + number=105, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='convolution_param', full_name='caffe.LayerParameter.convolution_param', index=19, + number=106, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crop_param', full_name='caffe.LayerParameter.crop_param', index=20, + number=144, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data_param', full_name='caffe.LayerParameter.data_param', index=21, + number=107, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dropout_param', full_name='caffe.LayerParameter.dropout_param', index=22, + number=108, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dummy_data_param', full_name='caffe.LayerParameter.dummy_data_param', index=23, + number=109, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='eltwise_param', full_name='caffe.LayerParameter.eltwise_param', index=24, + number=110, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='elu_param', full_name='caffe.LayerParameter.elu_param', index=25, + number=140, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='embed_param', full_name='caffe.LayerParameter.embed_param', index=26, + number=137, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='exp_param', full_name='caffe.LayerParameter.exp_param', index=27, + number=111, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='expmax_param', full_name='caffe.LayerParameter.expmax_param', index=28, + number=158, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='flatten_param', full_name='caffe.LayerParameter.flatten_param', index=29, + number=135, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hdf5_data_param', full_name='caffe.LayerParameter.hdf5_data_param', index=30, + number=112, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hdf5_output_param', full_name='caffe.LayerParameter.hdf5_output_param', index=31, + number=113, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hinge_loss_param', full_name='caffe.LayerParameter.hinge_loss_param', index=32, + number=114, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='image_data_param', full_name='caffe.LayerParameter.image_data_param', index=33, + number=115, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='infogain_loss_param', full_name='caffe.LayerParameter.infogain_loss_param', index=34, + number=116, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='inner_product_param', full_name='caffe.LayerParameter.inner_product_param', index=35, + number=117, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='input_param', full_name='caffe.LayerParameter.input_param', index=36, + number=143, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='log_param', full_name='caffe.LayerParameter.log_param', index=37, + number=134, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lrn_param', full_name='caffe.LayerParameter.lrn_param', index=38, + number=118, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='memory_data_param', full_name='caffe.LayerParameter.memory_data_param', index=39, + number=119, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mvn_param', full_name='caffe.LayerParameter.mvn_param', index=40, + number=120, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='parameter_param', full_name='caffe.LayerParameter.parameter_param', index=41, + number=145, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pooling_param', full_name='caffe.LayerParameter.pooling_param', index=42, + number=121, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='power_param', full_name='caffe.LayerParameter.power_param', index=43, + number=122, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='prelu_param', full_name='caffe.LayerParameter.prelu_param', index=44, + number=131, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='python_param', full_name='caffe.LayerParameter.python_param', index=45, + number=130, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='recurrent_param', full_name='caffe.LayerParameter.recurrent_param', index=46, + number=146, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='reduction_param', full_name='caffe.LayerParameter.reduction_param', index=47, + number=136, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='relu_param', full_name='caffe.LayerParameter.relu_param', index=48, + number=123, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='reshape_param', full_name='caffe.LayerParameter.reshape_param', index=49, + number=133, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale_param', full_name='caffe.LayerParameter.scale_param', index=50, + number=142, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sigmoid_param', full_name='caffe.LayerParameter.sigmoid_param', index=51, + number=124, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='softmax_param', full_name='caffe.LayerParameter.softmax_param', index=52, + number=125, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='spp_param', full_name='caffe.LayerParameter.spp_param', index=53, + number=132, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='slice_param', full_name='caffe.LayerParameter.slice_param', index=54, + number=126, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='tanh_param', full_name='caffe.LayerParameter.tanh_param', index=55, + number=127, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='threshold_param', full_name='caffe.LayerParameter.threshold_param', index=56, + number=128, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='tile_param', full_name='caffe.LayerParameter.tile_param', index=57, + number=138, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='window_data_param', full_name='caffe.LayerParameter.window_data_param', index=58, + number=129, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='coeff_schedule_param', full_name='caffe.LayerParameter.coeff_schedule_param', index=59, + number=148, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='augmentation_param', full_name='caffe.LayerParameter.augmentation_param', index=60, + number=149, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='correlation_param', full_name='caffe.LayerParameter.correlation_param', index=61, + number=150, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='l1_loss_param', full_name='caffe.LayerParameter.l1_loss_param', index=62, + number=151, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='writer_param', full_name='caffe.LayerParameter.writer_param', index=63, + number=152, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='reader_param', full_name='caffe.LayerParameter.reader_param', index=64, + number=153, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_param', full_name='caffe.LayerParameter.mean_param', index=65, + number=154, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='resample_param', full_name='caffe.LayerParameter.resample_param', index=66, + number=155, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='downsample_param', full_name='caffe.LayerParameter.downsample_param', index=67, + number=156, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='negsquare_param', full_name='caffe.LayerParameter.negsquare_param', index=68, + number=159, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='reshape_every_iter', full_name='caffe.LayerParameter.reshape_every_iter', index=69, + number=157, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=2802, + serialized_end=5968, +) + + +_GRIDPARAMETER = _descriptor.Descriptor( + name='GridParameter', + full_name='caffe.GridParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='height', full_name='caffe.GridParameter.height', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='width', full_name='caffe.GridParameter.width', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='batch', full_name='caffe.GridParameter.batch', index=2, + number=3, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=5970, + serialized_end=6031, +) + + +_AUGMENTATIONCOEFF = _descriptor.Descriptor( + name='AugmentationCoeff', + full_name='caffe.AugmentationCoeff', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='mirror', full_name='caffe.AugmentationCoeff.mirror', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dx', full_name='caffe.AugmentationCoeff.dx', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dy', full_name='caffe.AugmentationCoeff.dy', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='angle', full_name='caffe.AugmentationCoeff.angle', index=3, + number=4, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='zoom_x', full_name='caffe.AugmentationCoeff.zoom_x', index=4, + number=5, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='zoom_y', full_name='caffe.AugmentationCoeff.zoom_y', index=5, + number=6, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='gamma', full_name='caffe.AugmentationCoeff.gamma', index=6, + number=100, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='brightness', full_name='caffe.AugmentationCoeff.brightness', index=7, + number=101, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='contrast', full_name='caffe.AugmentationCoeff.contrast', index=8, + number=102, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='color1', full_name='caffe.AugmentationCoeff.color1', index=9, + number=103, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='color2', full_name='caffe.AugmentationCoeff.color2', index=10, + number=104, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='color3', full_name='caffe.AugmentationCoeff.color3', index=11, + number=105, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pow_nomean0', full_name='caffe.AugmentationCoeff.pow_nomean0', index=12, + number=10, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pow_nomean1', full_name='caffe.AugmentationCoeff.pow_nomean1', index=13, + number=11, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pow_nomean2', full_name='caffe.AugmentationCoeff.pow_nomean2', index=14, + number=12, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='add_nomean0', full_name='caffe.AugmentationCoeff.add_nomean0', index=15, + number=13, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='add_nomean1', full_name='caffe.AugmentationCoeff.add_nomean1', index=16, + number=14, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='add_nomean2', full_name='caffe.AugmentationCoeff.add_nomean2', index=17, + number=15, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mult_nomean0', full_name='caffe.AugmentationCoeff.mult_nomean0', index=18, + number=16, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mult_nomean1', full_name='caffe.AugmentationCoeff.mult_nomean1', index=19, + number=17, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mult_nomean2', full_name='caffe.AugmentationCoeff.mult_nomean2', index=20, + number=18, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pow_withmean0', full_name='caffe.AugmentationCoeff.pow_withmean0', index=21, + number=19, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pow_withmean1', full_name='caffe.AugmentationCoeff.pow_withmean1', index=22, + number=20, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pow_withmean2', full_name='caffe.AugmentationCoeff.pow_withmean2', index=23, + number=21, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='add_withmean0', full_name='caffe.AugmentationCoeff.add_withmean0', index=24, + number=22, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='add_withmean1', full_name='caffe.AugmentationCoeff.add_withmean1', index=25, + number=23, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='add_withmean2', full_name='caffe.AugmentationCoeff.add_withmean2', index=26, + number=24, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mult_withmean0', full_name='caffe.AugmentationCoeff.mult_withmean0', index=27, + number=25, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mult_withmean1', full_name='caffe.AugmentationCoeff.mult_withmean1', index=28, + number=26, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mult_withmean2', full_name='caffe.AugmentationCoeff.mult_withmean2', index=29, + number=27, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lmult_pow', full_name='caffe.AugmentationCoeff.lmult_pow', index=30, + number=28, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lmult_add', full_name='caffe.AugmentationCoeff.lmult_add', index=31, + number=29, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lmult_mult', full_name='caffe.AugmentationCoeff.lmult_mult', index=32, + number=30, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='col_angle', full_name='caffe.AugmentationCoeff.col_angle', index=33, + number=31, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fog_amount', full_name='caffe.AugmentationCoeff.fog_amount', index=34, + number=38, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fog_size', full_name='caffe.AugmentationCoeff.fog_size', index=35, + number=39, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='motion_blur_angle', full_name='caffe.AugmentationCoeff.motion_blur_angle', index=36, + number=40, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='motion_blur_size', full_name='caffe.AugmentationCoeff.motion_blur_size', index=37, + number=41, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shadow_angle', full_name='caffe.AugmentationCoeff.shadow_angle', index=38, + number=42, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shadow_distance', full_name='caffe.AugmentationCoeff.shadow_distance', index=39, + number=43, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shadow_strength', full_name='caffe.AugmentationCoeff.shadow_strength', index=40, + number=44, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='noise', full_name='caffe.AugmentationCoeff.noise', index=41, + number=45, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=6034, + serialized_end=7024, +) + + +_AUGMENTATIONPARAMETER = _descriptor.Descriptor( + name='AugmentationParameter', + full_name='caffe.AugmentationParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='crop_width', full_name='caffe.AugmentationParameter.crop_width', index=0, + number=33, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crop_height', full_name='caffe.AugmentationParameter.crop_height', index=1, + number=34, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='write_augmented', full_name='caffe.AugmentationParameter.write_augmented', index=2, + number=2, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_multiplier', full_name='caffe.AugmentationParameter.max_multiplier', index=3, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=255, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='augment_during_test', full_name='caffe.AugmentationParameter.augment_during_test', index=4, + number=4, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='recompute_mean', full_name='caffe.AugmentationParameter.recompute_mean', index=5, + number=5, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='write_mean', full_name='caffe.AugmentationParameter.write_mean', index=6, + number=6, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_per_pixel', full_name='caffe.AugmentationParameter.mean_per_pixel', index=7, + number=7, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean', full_name='caffe.AugmentationParameter.mean', index=8, + number=18, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mode', full_name='caffe.AugmentationParameter.mode', index=9, + number=8, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("add", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bottomwidth', full_name='caffe.AugmentationParameter.bottomwidth', index=10, + number=80, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bottomheight', full_name='caffe.AugmentationParameter.bottomheight', index=11, + number=81, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num', full_name='caffe.AugmentationParameter.num', index=12, + number=82, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='chromatic_eigvec', full_name='caffe.AugmentationParameter.chromatic_eigvec', index=13, + number=83, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mirror', full_name='caffe.AugmentationParameter.mirror', index=14, + number=10, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='translate', full_name='caffe.AugmentationParameter.translate', index=15, + number=11, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rotate', full_name='caffe.AugmentationParameter.rotate', index=16, + number=12, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='zoom', full_name='caffe.AugmentationParameter.zoom', index=17, + number=13, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='squeeze', full_name='caffe.AugmentationParameter.squeeze', index=18, + number=14, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='translate_x', full_name='caffe.AugmentationParameter.translate_x', index=19, + number=15, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='translate_y', full_name='caffe.AugmentationParameter.translate_y', index=20, + number=16, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='gamma', full_name='caffe.AugmentationParameter.gamma', index=21, + number=35, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='brightness', full_name='caffe.AugmentationParameter.brightness', index=22, + number=36, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='contrast', full_name='caffe.AugmentationParameter.contrast', index=23, + number=37, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='color', full_name='caffe.AugmentationParameter.color', index=24, + number=38, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lmult_pow', full_name='caffe.AugmentationParameter.lmult_pow', index=25, + number=20, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lmult_mult', full_name='caffe.AugmentationParameter.lmult_mult', index=26, + number=21, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lmult_add', full_name='caffe.AugmentationParameter.lmult_add', index=27, + number=22, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sat_pow', full_name='caffe.AugmentationParameter.sat_pow', index=28, + number=23, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sat_mult', full_name='caffe.AugmentationParameter.sat_mult', index=29, + number=24, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sat_add', full_name='caffe.AugmentationParameter.sat_add', index=30, + number=25, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='col_pow', full_name='caffe.AugmentationParameter.col_pow', index=31, + number=26, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='col_mult', full_name='caffe.AugmentationParameter.col_mult', index=32, + number=27, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='col_add', full_name='caffe.AugmentationParameter.col_add', index=33, + number=28, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='ladd_pow', full_name='caffe.AugmentationParameter.ladd_pow', index=34, + number=29, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='ladd_mult', full_name='caffe.AugmentationParameter.ladd_mult', index=35, + number=30, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='ladd_add', full_name='caffe.AugmentationParameter.ladd_add', index=36, + number=31, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='col_rotate', full_name='caffe.AugmentationParameter.col_rotate', index=37, + number=32, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fog_amount', full_name='caffe.AugmentationParameter.fog_amount', index=38, + number=100, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fog_size', full_name='caffe.AugmentationParameter.fog_size', index=39, + number=101, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='motion_blur_angle', full_name='caffe.AugmentationParameter.motion_blur_angle', index=40, + number=102, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='motion_blur_size', full_name='caffe.AugmentationParameter.motion_blur_size', index=41, + number=103, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shadow_angle', full_name='caffe.AugmentationParameter.shadow_angle', index=42, + number=104, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shadow_distance', full_name='caffe.AugmentationParameter.shadow_distance', index=43, + number=105, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shadow_strength', full_name='caffe.AugmentationParameter.shadow_strength', index=44, + number=106, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='noise', full_name='caffe.AugmentationParameter.noise', index=45, + number=107, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=7027, + serialized_end=9055, +) + + +_RANDOMGENERATORPARAMETER = _descriptor.Descriptor( + name='RandomGeneratorParameter', + full_name='caffe.RandomGeneratorParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='rand_type', full_name='caffe.RandomGeneratorParameter.rand_type', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("uniform", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='exp', full_name='caffe.RandomGeneratorParameter.exp', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean', full_name='caffe.RandomGeneratorParameter.mean', index=2, + number=4, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='spread', full_name='caffe.RandomGeneratorParameter.spread', index=3, + number=5, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='prob', full_name='caffe.RandomGeneratorParameter.prob', index=4, + number=6, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='apply_schedule', full_name='caffe.RandomGeneratorParameter.apply_schedule', index=5, + number=7, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='discretize', full_name='caffe.RandomGeneratorParameter.discretize', index=6, + number=8, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='multiplier', full_name='caffe.RandomGeneratorParameter.multiplier', index=7, + number=9, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=9058, + serialized_end=9265, +) + + +_L1LOSSPARAMETER = _descriptor.Descriptor( + name='L1LossParameter', + full_name='caffe.L1LossParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='l2_per_location', full_name='caffe.L1LossParameter.l2_per_location', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='l2_prescale_by_channels', full_name='caffe.L1LossParameter.l2_prescale_by_channels', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='normalize_by_num_entries', full_name='caffe.L1LossParameter.normalize_by_num_entries', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='epsilon', full_name='caffe.L1LossParameter.epsilon', index=3, + number=4, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.01, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='plateau', full_name='caffe.L1LossParameter.plateau', index=4, + number=3001, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='power', full_name='caffe.L1LossParameter.power', index=5, + number=5, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=9268, + serialized_end=9462, +) + + +_CORRELATIONPARAMETER = _descriptor.Descriptor( + name='CorrelationParameter', + full_name='caffe.CorrelationParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='pad', full_name='caffe.CorrelationParameter.pad', index=0, + number=2, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernel_size', full_name='caffe.CorrelationParameter.kernel_size', index=1, + number=3, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_displacement', full_name='caffe.CorrelationParameter.max_displacement', index=2, + number=4, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride_1', full_name='caffe.CorrelationParameter.stride_1', index=3, + number=5, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride_2', full_name='caffe.CorrelationParameter.stride_2', index=4, + number=6, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='single_direction', full_name='caffe.CorrelationParameter.single_direction', index=5, + number=8, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='do_abs', full_name='caffe.CorrelationParameter.do_abs', index=6, + number=7, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='correlation_type', full_name='caffe.CorrelationParameter.correlation_type', index=7, + number=15, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _CORRELATIONPARAMETER_CORRELATIONTYPE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=9465, + serialized_end=9772, +) + + +_DOWNSAMPLEPARAMETER = _descriptor.Descriptor( + name='DownsampleParameter', + full_name='caffe.DownsampleParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='top_height', full_name='caffe.DownsampleParameter.top_height', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='top_width', full_name='caffe.DownsampleParameter.top_width', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=9774, + serialized_end=9840, +) + + +_READERPARAMETER = _descriptor.Descriptor( + name='ReaderParameter', + full_name='caffe.ReaderParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='file', full_name='caffe.ReaderParameter.file', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num', full_name='caffe.ReaderParameter.num', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=9842, + serialized_end=9889, +) + + +_WRITERPARAMETER = _descriptor.Descriptor( + name='WriterParameter', + full_name='caffe.WriterParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='file', full_name='caffe.WriterParameter.file', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='folder', full_name='caffe.WriterParameter.folder', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='prefix', full_name='caffe.WriterParameter.prefix', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='suffix', full_name='caffe.WriterParameter.suffix', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='normalize', full_name='caffe.WriterParameter.normalize', index=4, + number=5, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.WriterParameter.scale', index=5, + number=6, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=9892, + serialized_end=10023, +) + + +_RESAMPLEPARAMETER = _descriptor.Descriptor( + name='ResampleParameter', + full_name='caffe.ResampleParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='antialias', full_name='caffe.ResampleParameter.antialias', index=0, + number=4, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='width', full_name='caffe.ResampleParameter.width', index=1, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='height', full_name='caffe.ResampleParameter.height', index=2, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='type', full_name='caffe.ResampleParameter.type', index=3, + number=3, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=2, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _RESAMPLEPARAMETER_RESAMPLETYPE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=10026, + serialized_end=10224, +) + + +_MEANPARAMETER = _descriptor.Descriptor( + name='MeanParameter', + full_name='caffe.MeanParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='operation', full_name='caffe.MeanParameter.operation', index=0, + number=1, type=14, cpp_type=8, label=2, + has_default_value=False, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='file', full_name='caffe.MeanParameter.file', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='caffe.MeanParameter.value', index=2, + number=3, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_scale', full_name='caffe.MeanParameter.mean_scale', index=3, + number=4, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='input_scale', full_name='caffe.MeanParameter.input_scale', index=4, + number=5, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='output_scale', full_name='caffe.MeanParameter.output_scale', index=5, + number=6, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _MEANPARAMETER_MEANOPERATION, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=10227, + serialized_end=10438, +) + + +_COEFFSCHEDULEPARAMETER = _descriptor.Descriptor( + name='CoeffScheduleParameter', + full_name='caffe.CoeffScheduleParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='half_life', full_name='caffe.CoeffScheduleParameter.half_life', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='initial_coeff', full_name='caffe.CoeffScheduleParameter.initial_coeff', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='final_coeff', full_name='caffe.CoeffScheduleParameter.final_coeff', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=10440, + serialized_end=10536, +) + + +_TRANSFORMATIONPARAMETER = _descriptor.Descriptor( + name='TransformationParameter', + full_name='caffe.TransformationParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.TransformationParameter.scale', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mirror', full_name='caffe.TransformationParameter.mirror', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crop_size', full_name='caffe.TransformationParameter.crop_size', index=2, + number=3, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_file', full_name='caffe.TransformationParameter.mean_file', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_value', full_name='caffe.TransformationParameter.mean_value', index=4, + number=5, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='force_color', full_name='caffe.TransformationParameter.force_color', index=5, + number=6, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='force_gray', full_name='caffe.TransformationParameter.force_gray', index=6, + number=7, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=10539, + serialized_end=10721, +) + + +_LOSSPARAMETER = _descriptor.Descriptor( + name='LossParameter', + full_name='caffe.LossParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='ignore_label', full_name='caffe.LossParameter.ignore_label', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='normalization', full_name='caffe.LossParameter.normalization', index=1, + number=3, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='normalize', full_name='caffe.LossParameter.normalize', index=2, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _LOSSPARAMETER_NORMALIZATIONMODE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=10724, + serialized_end=10918, +) + + +_ACCURACYPARAMETER = _descriptor.Descriptor( + name='AccuracyParameter', + full_name='caffe.AccuracyParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='top_k', full_name='caffe.AccuracyParameter.top_k', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.AccuracyParameter.axis', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='ignore_label', full_name='caffe.AccuracyParameter.ignore_label', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=10920, + serialized_end=10996, +) + + +_ARGMAXPARAMETER = _descriptor.Descriptor( + name='ArgMaxParameter', + full_name='caffe.ArgMaxParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='out_max_val', full_name='caffe.ArgMaxParameter.out_max_val', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='top_k', full_name='caffe.ArgMaxParameter.top_k', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.ArgMaxParameter.axis', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=10998, + serialized_end=11075, +) + + +_CONCATPARAMETER = _descriptor.Descriptor( + name='ConcatParameter', + full_name='caffe.ConcatParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.ConcatParameter.axis', index=0, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='concat_dim', full_name='caffe.ConcatParameter.concat_dim', index=1, + number=1, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=11077, + serialized_end=11134, +) + + +_BATCHNORMPARAMETER = _descriptor.Descriptor( + name='BatchNormParameter', + full_name='caffe.BatchNormParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='use_global_stats', full_name='caffe.BatchNormParameter.use_global_stats', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='moving_average_fraction', full_name='caffe.BatchNormParameter.moving_average_fraction', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.999, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='eps', full_name='caffe.BatchNormParameter.eps', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1e-05, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=11136, + serialized_end=11242, +) + + +_BIASPARAMETER = _descriptor.Descriptor( + name='BiasParameter', + full_name='caffe.BiasParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.BiasParameter.axis', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num_axes', full_name='caffe.BiasParameter.num_axes', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='filler', full_name='caffe.BiasParameter.filler', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=11244, + serialized_end=11337, +) + + +_CONTRASTIVELOSSPARAMETER = _descriptor.Descriptor( + name='ContrastiveLossParameter', + full_name='caffe.ContrastiveLossParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='margin', full_name='caffe.ContrastiveLossParameter.margin', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='legacy_version', full_name='caffe.ContrastiveLossParameter.legacy_version', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=11339, + serialized_end=11415, +) + + +_CONVOLUTIONPARAMETER = _descriptor.Descriptor( + name='ConvolutionParameter', + full_name='caffe.ConvolutionParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='num_output', full_name='caffe.ConvolutionParameter.num_output', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_term', full_name='caffe.ConvolutionParameter.bias_term', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pad', full_name='caffe.ConvolutionParameter.pad', index=2, + number=3, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernel_size', full_name='caffe.ConvolutionParameter.kernel_size', index=3, + number=4, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride', full_name='caffe.ConvolutionParameter.stride', index=4, + number=6, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dilation', full_name='caffe.ConvolutionParameter.dilation', index=5, + number=18, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pad_h', full_name='caffe.ConvolutionParameter.pad_h', index=6, + number=9, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pad_w', full_name='caffe.ConvolutionParameter.pad_w', index=7, + number=10, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernel_h', full_name='caffe.ConvolutionParameter.kernel_h', index=8, + number=11, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernel_w', full_name='caffe.ConvolutionParameter.kernel_w', index=9, + number=12, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride_h', full_name='caffe.ConvolutionParameter.stride_h', index=10, + number=13, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride_w', full_name='caffe.ConvolutionParameter.stride_w', index=11, + number=14, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='group', full_name='caffe.ConvolutionParameter.group', index=12, + number=5, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_filler', full_name='caffe.ConvolutionParameter.weight_filler', index=13, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_filler', full_name='caffe.ConvolutionParameter.bias_filler', index=14, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.ConvolutionParameter.engine', index=15, + number=15, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.ConvolutionParameter.axis', index=16, + number=16, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='force_nd_im2col', full_name='caffe.ConvolutionParameter.force_nd_im2col', index=17, + number=17, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _CONVOLUTIONPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=11418, + serialized_end=11926, +) + + +_CROPPARAMETER = _descriptor.Descriptor( + name='CropParameter', + full_name='caffe.CropParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.CropParameter.axis', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=2, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='offset', full_name='caffe.CropParameter.offset', index=1, + number=2, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=11928, + serialized_end=11976, +) + + +_DATAPARAMETER = _descriptor.Descriptor( + name='DataParameter', + full_name='caffe.DataParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='source', full_name='caffe.DataParameter.source', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='batch_size', full_name='caffe.DataParameter.batch_size', index=1, + number=4, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rand_skip', full_name='caffe.DataParameter.rand_skip', index=2, + number=7, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='backend', full_name='caffe.DataParameter.backend', index=3, + number=8, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.DataParameter.scale', index=4, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_file', full_name='caffe.DataParameter.mean_file', index=5, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crop_size', full_name='caffe.DataParameter.crop_size', index=6, + number=5, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mirror', full_name='caffe.DataParameter.mirror', index=7, + number=6, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='force_encoded_color', full_name='caffe.DataParameter.force_encoded_color', index=8, + number=9, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='prefetch', full_name='caffe.DataParameter.prefetch', index=9, + number=10, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=4, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='disk_reader_threads', full_name='caffe.DataParameter.disk_reader_threads', index=10, + number=4001, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='huge_video_dataset', full_name='caffe.DataParameter.huge_video_dataset', index=11, + number=7000, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='limit_samples', full_name='caffe.DataParameter.limit_samples', index=12, + number=7001, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='preselection_file', full_name='caffe.DataParameter.preselection_file', index=13, + number=3001, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='preselection_label', full_name='caffe.DataParameter.preselection_label', index=14, + number=3002, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='range_start', full_name='caffe.DataParameter.range_start', index=15, + number=3003, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='range_end', full_name='caffe.DataParameter.range_end', index=16, + number=3004, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rand_permute', full_name='caffe.DataParameter.rand_permute', index=17, + number=3005, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rand_permute_order', full_name='caffe.DataParameter.rand_permute_order', index=18, + number=3006, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rand_permute_seed', full_name='caffe.DataParameter.rand_permute_seed', index=19, + number=3007, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='slice_point', full_name='caffe.DataParameter.slice_point', index=20, + number=3008, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='encoding', full_name='caffe.DataParameter.encoding', index=21, + number=3009, type=14, cpp_type=8, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='verbose', full_name='caffe.DataParameter.verbose', index=22, + number=3010, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='subtract', full_name='caffe.DataParameter.subtract', index=23, + number=3011, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='permute_every_iter', full_name='caffe.DataParameter.permute_every_iter', index=24, + number=3012, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='block_size', full_name='caffe.DataParameter.block_size', index=25, + number=3013, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _DATAPARAMETER_DB, + _DATAPARAMETER_CHANNELENCODING, + _DATAPARAMETER_RANDPERMORDER, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=11979, + serialized_end=12942, +) + + +_DROPOUTPARAMETER = _descriptor.Descriptor( + name='DropoutParameter', + full_name='caffe.DropoutParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='dropout_ratio', full_name='caffe.DropoutParameter.dropout_ratio', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=12944, + serialized_end=12990, +) + + +_DUMMYDATAPARAMETER = _descriptor.Descriptor( + name='DummyDataParameter', + full_name='caffe.DummyDataParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='data_filler', full_name='caffe.DummyDataParameter.data_filler', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shape', full_name='caffe.DummyDataParameter.shape', index=1, + number=6, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num', full_name='caffe.DummyDataParameter.num', index=2, + number=2, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='channels', full_name='caffe.DummyDataParameter.channels', index=3, + number=3, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='height', full_name='caffe.DummyDataParameter.height', index=4, + number=4, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='width', full_name='caffe.DummyDataParameter.width', index=5, + number=5, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=12993, + serialized_end=13153, +) + + +_ELTWISEPARAMETER = _descriptor.Descriptor( + name='EltwiseParameter', + full_name='caffe.EltwiseParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='operation', full_name='caffe.EltwiseParameter.operation', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='coeff', full_name='caffe.EltwiseParameter.coeff', index=1, + number=2, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stable_prod_grad', full_name='caffe.EltwiseParameter.stable_prod_grad', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _ELTWISEPARAMETER_ELTWISEOP, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13156, + serialized_end=13321, +) + + +_ELUPARAMETER = _descriptor.Descriptor( + name='ELUParameter', + full_name='caffe.ELUParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='alpha', full_name='caffe.ELUParameter.alpha', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13323, + serialized_end=13355, +) + + +_EMBEDPARAMETER = _descriptor.Descriptor( + name='EmbedParameter', + full_name='caffe.EmbedParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='num_output', full_name='caffe.EmbedParameter.num_output', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='input_dim', full_name='caffe.EmbedParameter.input_dim', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_term', full_name='caffe.EmbedParameter.bias_term', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_filler', full_name='caffe.EmbedParameter.weight_filler', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_filler', full_name='caffe.EmbedParameter.bias_filler', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13358, + serialized_end=13530, +) + + +_EXPPARAMETER = _descriptor.Descriptor( + name='ExpParameter', + full_name='caffe.ExpParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='base', full_name='caffe.ExpParameter.base', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.ExpParameter.scale', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shift', full_name='caffe.ExpParameter.shift', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13532, + serialized_end=13600, +) + + +_EXPMAXPARAMETER = _descriptor.Descriptor( + name='ExpMaxParameter', + full_name='caffe.ExpMaxParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='base', full_name='caffe.ExpMaxParameter.base', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.ExpMaxParameter.scale', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shift', full_name='caffe.ExpMaxParameter.shift', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13602, + serialized_end=13673, +) + + +_FLATTENPARAMETER = _descriptor.Descriptor( + name='FlattenParameter', + full_name='caffe.FlattenParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.FlattenParameter.axis', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end_axis', full_name='caffe.FlattenParameter.end_axis', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13675, + serialized_end=13732, +) + + +_HDF5DATAPARAMETER = _descriptor.Descriptor( + name='HDF5DataParameter', + full_name='caffe.HDF5DataParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='source', full_name='caffe.HDF5DataParameter.source', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='batch_size', full_name='caffe.HDF5DataParameter.batch_size', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shuffle', full_name='caffe.HDF5DataParameter.shuffle', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13734, + serialized_end=13813, +) + + +_HDF5OUTPUTPARAMETER = _descriptor.Descriptor( + name='HDF5OutputParameter', + full_name='caffe.HDF5OutputParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='file_name', full_name='caffe.HDF5OutputParameter.file_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13815, + serialized_end=13855, +) + + +_HINGELOSSPARAMETER = _descriptor.Descriptor( + name='HingeLossParameter', + full_name='caffe.HingeLossParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='norm', full_name='caffe.HingeLossParameter.norm', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _HINGELOSSPARAMETER_NORM, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13857, + serialized_end=13951, +) + + +_IMAGEDATAPARAMETER = _descriptor.Descriptor( + name='ImageDataParameter', + full_name='caffe.ImageDataParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='source', full_name='caffe.ImageDataParameter.source', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='batch_size', full_name='caffe.ImageDataParameter.batch_size', index=1, + number=4, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rand_skip', full_name='caffe.ImageDataParameter.rand_skip', index=2, + number=7, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shuffle', full_name='caffe.ImageDataParameter.shuffle', index=3, + number=8, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='new_height', full_name='caffe.ImageDataParameter.new_height', index=4, + number=9, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='new_width', full_name='caffe.ImageDataParameter.new_width', index=5, + number=10, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='is_color', full_name='caffe.ImageDataParameter.is_color', index=6, + number=11, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.ImageDataParameter.scale', index=7, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_file', full_name='caffe.ImageDataParameter.mean_file', index=8, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crop_size', full_name='caffe.ImageDataParameter.crop_size', index=9, + number=5, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mirror', full_name='caffe.ImageDataParameter.mirror', index=10, + number=6, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='root_folder', full_name='caffe.ImageDataParameter.root_folder', index=11, + number=12, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=13954, + serialized_end=14233, +) + + +_INFOGAINLOSSPARAMETER = _descriptor.Descriptor( + name='InfogainLossParameter', + full_name='caffe.InfogainLossParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='source', full_name='caffe.InfogainLossParameter.source', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=14235, + serialized_end=14274, +) + + +_INNERPRODUCTPARAMETER = _descriptor.Descriptor( + name='InnerProductParameter', + full_name='caffe.InnerProductParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='num_output', full_name='caffe.InnerProductParameter.num_output', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_term', full_name='caffe.InnerProductParameter.bias_term', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_filler', full_name='caffe.InnerProductParameter.weight_filler', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_filler', full_name='caffe.InnerProductParameter.bias_filler', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.InnerProductParameter.axis', index=4, + number=5, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transpose', full_name='caffe.InnerProductParameter.transpose', index=5, + number=6, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=14277, + serialized_end=14480, +) + + +_INPUTPARAMETER = _descriptor.Descriptor( + name='InputParameter', + full_name='caffe.InputParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='shape', full_name='caffe.InputParameter.shape', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=14482, + serialized_end=14531, +) + + +_LOGPARAMETER = _descriptor.Descriptor( + name='LogParameter', + full_name='caffe.LogParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='base', full_name='caffe.LogParameter.base', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.LogParameter.scale', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shift', full_name='caffe.LogParameter.shift', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=14533, + serialized_end=14601, +) + + +_LRNPARAMETER = _descriptor.Descriptor( + name='LRNParameter', + full_name='caffe.LRNParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='local_size', full_name='caffe.LRNParameter.local_size', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='alpha', full_name='caffe.LRNParameter.alpha', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='beta', full_name='caffe.LRNParameter.beta', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.75, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='norm_region', full_name='caffe.LRNParameter.norm_region', index=3, + number=4, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='k', full_name='caffe.LRNParameter.k', index=4, + number=5, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.LRNParameter.engine', index=5, + number=6, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shift', full_name='caffe.LRNParameter.shift', index=6, + number=7, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _LRNPARAMETER_NORMREGION, + _LRNPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=14604, + serialized_end=14934, +) + + +_MEMORYDATAPARAMETER = _descriptor.Descriptor( + name='MemoryDataParameter', + full_name='caffe.MemoryDataParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='batch_size', full_name='caffe.MemoryDataParameter.batch_size', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='channels', full_name='caffe.MemoryDataParameter.channels', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='height', full_name='caffe.MemoryDataParameter.height', index=2, + number=3, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='width', full_name='caffe.MemoryDataParameter.width', index=3, + number=4, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=14936, + serialized_end=15026, +) + + +_MVNPARAMETER = _descriptor.Descriptor( + name='MVNParameter', + full_name='caffe.MVNParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='normalize_variance', full_name='caffe.MVNParameter.normalize_variance', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='across_channels', full_name='caffe.MVNParameter.across_channels', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='eps', full_name='caffe.MVNParameter.eps', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1e-09, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=15028, + serialized_end=15128, +) + + +_PARAMETERPARAMETER = _descriptor.Descriptor( + name='ParameterParameter', + full_name='caffe.ParameterParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='shape', full_name='caffe.ParameterParameter.shape', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=15130, + serialized_end=15183, +) + + +_POOLINGPARAMETER = _descriptor.Descriptor( + name='PoolingParameter', + full_name='caffe.PoolingParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='pool', full_name='caffe.PoolingParameter.pool', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pad', full_name='caffe.PoolingParameter.pad', index=1, + number=4, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pad_h', full_name='caffe.PoolingParameter.pad_h', index=2, + number=9, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pad_w', full_name='caffe.PoolingParameter.pad_w', index=3, + number=10, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernel_size', full_name='caffe.PoolingParameter.kernel_size', index=4, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernel_h', full_name='caffe.PoolingParameter.kernel_h', index=5, + number=5, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernel_w', full_name='caffe.PoolingParameter.kernel_w', index=6, + number=6, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride', full_name='caffe.PoolingParameter.stride', index=7, + number=3, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride_h', full_name='caffe.PoolingParameter.stride_h', index=8, + number=7, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride_w', full_name='caffe.PoolingParameter.stride_w', index=9, + number=8, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.PoolingParameter.engine', index=10, + number=11, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='global_pooling', full_name='caffe.PoolingParameter.global_pooling', index=11, + number=12, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _POOLINGPARAMETER_POOLMETHOD, + _POOLINGPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=15186, + serialized_end=15604, +) + + +_POWERPARAMETER = _descriptor.Descriptor( + name='PowerParameter', + full_name='caffe.PowerParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='power', full_name='caffe.PowerParameter.power', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.PowerParameter.scale', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shift', full_name='caffe.PowerParameter.shift', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=15606, + serialized_end=15676, +) + + +_NEGSQUAREPARAMETER = _descriptor.Descriptor( + name='NegSquareParameter', + full_name='caffe.NegSquareParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=15678, + serialized_end=15698, +) + + +_PYTHONPARAMETER = _descriptor.Descriptor( + name='PythonParameter', + full_name='caffe.PythonParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='module', full_name='caffe.PythonParameter.module', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='layer', full_name='caffe.PythonParameter.layer', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='param_str', full_name='caffe.PythonParameter.param_str', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='share_in_parallel', full_name='caffe.PythonParameter.share_in_parallel', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=15700, + serialized_end=15803, +) + + +_RECURRENTPARAMETER = _descriptor.Descriptor( + name='RecurrentParameter', + full_name='caffe.RecurrentParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='num_output', full_name='caffe.RecurrentParameter.num_output', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_filler', full_name='caffe.RecurrentParameter.weight_filler', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_filler', full_name='caffe.RecurrentParameter.bias_filler', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='debug_info', full_name='caffe.RecurrentParameter.debug_info', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='expose_hidden', full_name='caffe.RecurrentParameter.expose_hidden', index=4, + number=5, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=15806, + serialized_end=15998, +) + + +_REDUCTIONPARAMETER = _descriptor.Descriptor( + name='ReductionParameter', + full_name='caffe.ReductionParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='operation', full_name='caffe.ReductionParameter.operation', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.ReductionParameter.axis', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='coeff', full_name='caffe.ReductionParameter.coeff', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _REDUCTIONPARAMETER_REDUCTIONOP, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16001, + serialized_end=16174, +) + + +_RELUPARAMETER = _descriptor.Descriptor( + name='ReLUParameter', + full_name='caffe.ReLUParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='negative_slope', full_name='caffe.ReLUParameter.negative_slope', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.ReLUParameter.engine', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _RELUPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16177, + serialized_end=16318, +) + + +_RESHAPEPARAMETER = _descriptor.Descriptor( + name='ReshapeParameter', + full_name='caffe.ReshapeParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='shape', full_name='caffe.ReshapeParameter.shape', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.ReshapeParameter.axis', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num_axes', full_name='caffe.ReshapeParameter.num_axes', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=-1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16320, + serialized_end=16410, +) + + +_SCALEPARAMETER = _descriptor.Descriptor( + name='ScaleParameter', + full_name='caffe.ScaleParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.ScaleParameter.axis', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num_axes', full_name='caffe.ScaleParameter.num_axes', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='filler', full_name='caffe.ScaleParameter.filler', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_term', full_name='caffe.ScaleParameter.bias_term', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_filler', full_name='caffe.ScaleParameter.bias_filler', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16413, + serialized_end=16578, +) + + +_SIGMOIDPARAMETER = _descriptor.Descriptor( + name='SigmoidParameter', + full_name='caffe.SigmoidParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.SigmoidParameter.engine', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _SIGMOIDPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16580, + serialized_end=16700, +) + + +_SLICEPARAMETER = _descriptor.Descriptor( + name='SliceParameter', + full_name='caffe.SliceParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.SliceParameter.axis', index=0, + number=3, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='slice_point', full_name='caffe.SliceParameter.slice_point', index=1, + number=2, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='slice_dim', full_name='caffe.SliceParameter.slice_dim', index=2, + number=1, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16702, + serialized_end=16778, +) + + +_SOFTMAXPARAMETER = _descriptor.Descriptor( + name='SoftmaxParameter', + full_name='caffe.SoftmaxParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.SoftmaxParameter.engine', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.SoftmaxParameter.axis', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _SOFTMAXPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16781, + serialized_end=16918, +) + + +_TANHPARAMETER = _descriptor.Descriptor( + name='TanHParameter', + full_name='caffe.TanHParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.TanHParameter.engine', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _TANHPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=16920, + serialized_end=17034, +) + + +_TILEPARAMETER = _descriptor.Descriptor( + name='TileParameter', + full_name='caffe.TileParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='axis', full_name='caffe.TileParameter.axis', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='tiles', full_name='caffe.TileParameter.tiles', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=17036, + serialized_end=17083, +) + + +_THRESHOLDPARAMETER = _descriptor.Descriptor( + name='ThresholdParameter', + full_name='caffe.ThresholdParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='threshold', full_name='caffe.ThresholdParameter.threshold', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=17085, + serialized_end=17127, +) + + +_WINDOWDATAPARAMETER = _descriptor.Descriptor( + name='WindowDataParameter', + full_name='caffe.WindowDataParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='source', full_name='caffe.WindowDataParameter.source', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.WindowDataParameter.scale', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mean_file', full_name='caffe.WindowDataParameter.mean_file', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='batch_size', full_name='caffe.WindowDataParameter.batch_size', index=3, + number=4, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crop_size', full_name='caffe.WindowDataParameter.crop_size', index=4, + number=5, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mirror', full_name='caffe.WindowDataParameter.mirror', index=5, + number=6, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fg_threshold', full_name='caffe.WindowDataParameter.fg_threshold', index=6, + number=7, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bg_threshold', full_name='caffe.WindowDataParameter.bg_threshold', index=7, + number=8, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fg_fraction', full_name='caffe.WindowDataParameter.fg_fraction', index=8, + number=9, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.25, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='context_pad', full_name='caffe.WindowDataParameter.context_pad', index=9, + number=10, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='crop_mode', full_name='caffe.WindowDataParameter.crop_mode', index=10, + number=11, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("warp", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='cache_images', full_name='caffe.WindowDataParameter.cache_images', index=11, + number=12, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='root_folder', full_name='caffe.WindowDataParameter.root_folder', index=12, + number=13, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=17130, + serialized_end=17451, +) + + +_SPPPARAMETER = _descriptor.Descriptor( + name='SPPParameter', + full_name='caffe.SPPParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='pyramid_height', full_name='caffe.SPPParameter.pyramid_height', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pool', full_name='caffe.SPPParameter.pool', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='engine', full_name='caffe.SPPParameter.engine', index=2, + number=6, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _SPPPARAMETER_POOLMETHOD, + _SPPPARAMETER_ENGINE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=17454, + serialized_end=17689, +) + + +_V1LAYERPARAMETER = _descriptor.Descriptor( + name='V1LayerParameter', + full_name='caffe.V1LayerParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='bottom', full_name='caffe.V1LayerParameter.bottom', index=0, + number=2, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='top', full_name='caffe.V1LayerParameter.top', index=1, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='name', full_name='caffe.V1LayerParameter.name', index=2, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='include', full_name='caffe.V1LayerParameter.include', index=3, + number=32, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='exclude', full_name='caffe.V1LayerParameter.exclude', index=4, + number=33, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='type', full_name='caffe.V1LayerParameter.type', index=5, + number=5, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='blobs', full_name='caffe.V1LayerParameter.blobs', index=6, + number=6, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='param', full_name='caffe.V1LayerParameter.param', index=7, + number=1001, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='blob_share_mode', full_name='caffe.V1LayerParameter.blob_share_mode', index=8, + number=1002, type=14, cpp_type=8, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='blobs_lr', full_name='caffe.V1LayerParameter.blobs_lr', index=9, + number=7, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_decay', full_name='caffe.V1LayerParameter.weight_decay', index=10, + number=8, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='loss_weight', full_name='caffe.V1LayerParameter.loss_weight', index=11, + number=35, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='accuracy_param', full_name='caffe.V1LayerParameter.accuracy_param', index=12, + number=27, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='argmax_param', full_name='caffe.V1LayerParameter.argmax_param', index=13, + number=23, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='concat_param', full_name='caffe.V1LayerParameter.concat_param', index=14, + number=9, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='contrastive_loss_param', full_name='caffe.V1LayerParameter.contrastive_loss_param', index=15, + number=40, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='convolution_param', full_name='caffe.V1LayerParameter.convolution_param', index=16, + number=10, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data_param', full_name='caffe.V1LayerParameter.data_param', index=17, + number=11, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dropout_param', full_name='caffe.V1LayerParameter.dropout_param', index=18, + number=12, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dummy_data_param', full_name='caffe.V1LayerParameter.dummy_data_param', index=19, + number=26, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='eltwise_param', full_name='caffe.V1LayerParameter.eltwise_param', index=20, + number=24, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='exp_param', full_name='caffe.V1LayerParameter.exp_param', index=21, + number=41, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hdf5_data_param', full_name='caffe.V1LayerParameter.hdf5_data_param', index=22, + number=13, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hdf5_output_param', full_name='caffe.V1LayerParameter.hdf5_output_param', index=23, + number=14, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hinge_loss_param', full_name='caffe.V1LayerParameter.hinge_loss_param', index=24, + number=29, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='image_data_param', full_name='caffe.V1LayerParameter.image_data_param', index=25, + number=15, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='infogain_loss_param', full_name='caffe.V1LayerParameter.infogain_loss_param', index=26, + number=16, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='inner_product_param', full_name='caffe.V1LayerParameter.inner_product_param', index=27, + number=17, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lrn_param', full_name='caffe.V1LayerParameter.lrn_param', index=28, + number=18, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='memory_data_param', full_name='caffe.V1LayerParameter.memory_data_param', index=29, + number=22, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mvn_param', full_name='caffe.V1LayerParameter.mvn_param', index=30, + number=34, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pooling_param', full_name='caffe.V1LayerParameter.pooling_param', index=31, + number=19, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='power_param', full_name='caffe.V1LayerParameter.power_param', index=32, + number=21, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='relu_param', full_name='caffe.V1LayerParameter.relu_param', index=33, + number=30, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sigmoid_param', full_name='caffe.V1LayerParameter.sigmoid_param', index=34, + number=38, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='softmax_param', full_name='caffe.V1LayerParameter.softmax_param', index=35, + number=39, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='slice_param', full_name='caffe.V1LayerParameter.slice_param', index=36, + number=31, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='tanh_param', full_name='caffe.V1LayerParameter.tanh_param', index=37, + number=37, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='threshold_param', full_name='caffe.V1LayerParameter.threshold_param', index=38, + number=25, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='window_data_param', full_name='caffe.V1LayerParameter.window_data_param', index=39, + number=20, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transform_param', full_name='caffe.V1LayerParameter.transform_param', index=40, + number=36, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='loss_param', full_name='caffe.V1LayerParameter.loss_param', index=41, + number=42, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='layer', full_name='caffe.V1LayerParameter.layer', index=42, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _V1LAYERPARAMETER_LAYERTYPE, + _V1LAYERPARAMETER_DIMCHECKMODE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=17692, + serialized_end=20220, +) + + +_V0LAYERPARAMETER = _descriptor.Descriptor( + name='V0LayerParameter', + full_name='caffe.V0LayerParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='caffe.V0LayerParameter.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='type', full_name='caffe.V0LayerParameter.type', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num_output', full_name='caffe.V0LayerParameter.num_output', index=2, + number=3, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='biasterm', full_name='caffe.V0LayerParameter.biasterm', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_filler', full_name='caffe.V0LayerParameter.weight_filler', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='bias_filler', full_name='caffe.V0LayerParameter.bias_filler', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pad', full_name='caffe.V0LayerParameter.pad', index=6, + number=7, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='kernelsize', full_name='caffe.V0LayerParameter.kernelsize', index=7, + number=8, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='group', full_name='caffe.V0LayerParameter.group', index=8, + number=9, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='stride', full_name='caffe.V0LayerParameter.stride', index=9, + number=10, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pool', full_name='caffe.V0LayerParameter.pool', index=10, + number=11, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='dropout_ratio', full_name='caffe.V0LayerParameter.dropout_ratio', index=11, + number=12, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='local_size', full_name='caffe.V0LayerParameter.local_size', index=12, + number=13, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='alpha', full_name='caffe.V0LayerParameter.alpha', index=13, + number=14, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='beta', full_name='caffe.V0LayerParameter.beta', index=14, + number=15, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.75, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='k', full_name='caffe.V0LayerParameter.k', index=15, + number=22, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='source', full_name='caffe.V0LayerParameter.source', index=16, + number=16, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='scale', full_name='caffe.V0LayerParameter.scale', index=17, + number=17, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='meanfile', full_name='caffe.V0LayerParameter.meanfile', index=18, + number=18, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='batchsize', full_name='caffe.V0LayerParameter.batchsize', index=19, + number=19, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='cropsize', full_name='caffe.V0LayerParameter.cropsize', index=20, + number=20, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mirror', full_name='caffe.V0LayerParameter.mirror', index=21, + number=21, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='blobs', full_name='caffe.V0LayerParameter.blobs', index=22, + number=50, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='blobs_lr', full_name='caffe.V0LayerParameter.blobs_lr', index=23, + number=51, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='weight_decay', full_name='caffe.V0LayerParameter.weight_decay', index=24, + number=52, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rand_skip', full_name='caffe.V0LayerParameter.rand_skip', index=25, + number=53, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='det_fg_threshold', full_name='caffe.V0LayerParameter.det_fg_threshold', index=26, + number=54, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='det_bg_threshold', full_name='caffe.V0LayerParameter.det_bg_threshold', index=27, + number=55, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.5, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='det_fg_fraction', full_name='caffe.V0LayerParameter.det_fg_fraction', index=28, + number=56, type=2, cpp_type=6, label=1, + has_default_value=True, default_value=0.25, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='det_context_pad', full_name='caffe.V0LayerParameter.det_context_pad', index=29, + number=58, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='det_crop_mode', full_name='caffe.V0LayerParameter.det_crop_mode', index=30, + number=59, type=9, cpp_type=9, label=1, + has_default_value=True, default_value=unicode("warp", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='new_num', full_name='caffe.V0LayerParameter.new_num', index=31, + number=60, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='new_channels', full_name='caffe.V0LayerParameter.new_channels', index=32, + number=61, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='new_height', full_name='caffe.V0LayerParameter.new_height', index=33, + number=62, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='new_width', full_name='caffe.V0LayerParameter.new_width', index=34, + number=63, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='shuffle_images', full_name='caffe.V0LayerParameter.shuffle_images', index=35, + number=64, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='concat_dim', full_name='caffe.V0LayerParameter.concat_dim', index=36, + number=65, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hdf5_output_param', full_name='caffe.V0LayerParameter.hdf5_output_param', index=37, + number=1001, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _V0LAYERPARAMETER_POOLMETHOD, + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=20223, + serialized_end=21244, +) + + +_PRELUPARAMETER = _descriptor.Descriptor( + name='PReLUParameter', + full_name='caffe.PReLUParameter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='filler', full_name='caffe.PReLUParameter.filler', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='channel_shared', full_name='caffe.PReLUParameter.channel_shared', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=21246, + serialized_end=21333, +) + +_BLOBPROTO.fields_by_name['shape'].message_type = _BLOBSHAPE +_BLOBPROTOVECTOR.fields_by_name['blobs'].message_type = _BLOBPROTO +_FILLERPARAMETER.fields_by_name['variance_norm'].enum_type = _FILLERPARAMETER_VARIANCENORM +_FILLERPARAMETER_VARIANCENORM.containing_type = _FILLERPARAMETER; +_NETPARAMETER.fields_by_name['input_shape'].message_type = _BLOBSHAPE +_NETPARAMETER.fields_by_name['state'].message_type = _NETSTATE +_NETPARAMETER.fields_by_name['layer'].message_type = _LAYERPARAMETER +_NETPARAMETER.fields_by_name['layers'].message_type = _V1LAYERPARAMETER +_SOLVERPARAMETER.fields_by_name['net_param'].message_type = _NETPARAMETER +_SOLVERPARAMETER.fields_by_name['train_net_param'].message_type = _NETPARAMETER +_SOLVERPARAMETER.fields_by_name['test_net_param'].message_type = _NETPARAMETER +_SOLVERPARAMETER.fields_by_name['train_state'].message_type = _NETSTATE +_SOLVERPARAMETER.fields_by_name['test_state'].message_type = _NETSTATE +_SOLVERPARAMETER.fields_by_name['snapshot_format'].enum_type = _SOLVERPARAMETER_SNAPSHOTFORMAT +_SOLVERPARAMETER.fields_by_name['solver_mode'].enum_type = _SOLVERPARAMETER_SOLVERMODE +_SOLVERPARAMETER.fields_by_name['solver_type'].enum_type = _SOLVERPARAMETER_SOLVERTYPE +_SOLVERPARAMETER_SNAPSHOTFORMAT.containing_type = _SOLVERPARAMETER; +_SOLVERPARAMETER_SOLVERMODE.containing_type = _SOLVERPARAMETER; +_SOLVERPARAMETER_SOLVERTYPE.containing_type = _SOLVERPARAMETER; +_SOLVERSTATE.fields_by_name['history'].message_type = _BLOBPROTO +_NETSTATE.fields_by_name['phase'].enum_type = _PHASE +_NETSTATERULE.fields_by_name['phase'].enum_type = _PHASE +_PARAMSPEC.fields_by_name['share_mode'].enum_type = _PARAMSPEC_DIMCHECKMODE +_PARAMSPEC_DIMCHECKMODE.containing_type = _PARAMSPEC; +_LAYERPARAMETER.fields_by_name['phase'].enum_type = _PHASE +_LAYERPARAMETER.fields_by_name['param'].message_type = _PARAMSPEC +_LAYERPARAMETER.fields_by_name['blobs'].message_type = _BLOBPROTO +_LAYERPARAMETER.fields_by_name['include'].message_type = _NETSTATERULE +_LAYERPARAMETER.fields_by_name['exclude'].message_type = _NETSTATERULE +_LAYERPARAMETER.fields_by_name['transform_param'].message_type = _TRANSFORMATIONPARAMETER +_LAYERPARAMETER.fields_by_name['loss_param'].message_type = _LOSSPARAMETER +_LAYERPARAMETER.fields_by_name['accuracy_param'].message_type = _ACCURACYPARAMETER +_LAYERPARAMETER.fields_by_name['argmax_param'].message_type = _ARGMAXPARAMETER +_LAYERPARAMETER.fields_by_name['batch_norm_param'].message_type = _BATCHNORMPARAMETER +_LAYERPARAMETER.fields_by_name['bias_param'].message_type = _BIASPARAMETER +_LAYERPARAMETER.fields_by_name['concat_param'].message_type = _CONCATPARAMETER +_LAYERPARAMETER.fields_by_name['contrastive_loss_param'].message_type = _CONTRASTIVELOSSPARAMETER +_LAYERPARAMETER.fields_by_name['convolution_param'].message_type = _CONVOLUTIONPARAMETER +_LAYERPARAMETER.fields_by_name['crop_param'].message_type = _CROPPARAMETER +_LAYERPARAMETER.fields_by_name['data_param'].message_type = _DATAPARAMETER +_LAYERPARAMETER.fields_by_name['dropout_param'].message_type = _DROPOUTPARAMETER +_LAYERPARAMETER.fields_by_name['dummy_data_param'].message_type = _DUMMYDATAPARAMETER +_LAYERPARAMETER.fields_by_name['eltwise_param'].message_type = _ELTWISEPARAMETER +_LAYERPARAMETER.fields_by_name['elu_param'].message_type = _ELUPARAMETER +_LAYERPARAMETER.fields_by_name['embed_param'].message_type = _EMBEDPARAMETER +_LAYERPARAMETER.fields_by_name['exp_param'].message_type = _EXPPARAMETER +_LAYERPARAMETER.fields_by_name['expmax_param'].message_type = _EXPMAXPARAMETER +_LAYERPARAMETER.fields_by_name['flatten_param'].message_type = _FLATTENPARAMETER +_LAYERPARAMETER.fields_by_name['hdf5_data_param'].message_type = _HDF5DATAPARAMETER +_LAYERPARAMETER.fields_by_name['hdf5_output_param'].message_type = _HDF5OUTPUTPARAMETER +_LAYERPARAMETER.fields_by_name['hinge_loss_param'].message_type = _HINGELOSSPARAMETER +_LAYERPARAMETER.fields_by_name['image_data_param'].message_type = _IMAGEDATAPARAMETER +_LAYERPARAMETER.fields_by_name['infogain_loss_param'].message_type = _INFOGAINLOSSPARAMETER +_LAYERPARAMETER.fields_by_name['inner_product_param'].message_type = _INNERPRODUCTPARAMETER +_LAYERPARAMETER.fields_by_name['input_param'].message_type = _INPUTPARAMETER +_LAYERPARAMETER.fields_by_name['log_param'].message_type = _LOGPARAMETER +_LAYERPARAMETER.fields_by_name['lrn_param'].message_type = _LRNPARAMETER +_LAYERPARAMETER.fields_by_name['memory_data_param'].message_type = _MEMORYDATAPARAMETER +_LAYERPARAMETER.fields_by_name['mvn_param'].message_type = _MVNPARAMETER +_LAYERPARAMETER.fields_by_name['parameter_param'].message_type = _PARAMETERPARAMETER +_LAYERPARAMETER.fields_by_name['pooling_param'].message_type = _POOLINGPARAMETER +_LAYERPARAMETER.fields_by_name['power_param'].message_type = _POWERPARAMETER +_LAYERPARAMETER.fields_by_name['prelu_param'].message_type = _PRELUPARAMETER +_LAYERPARAMETER.fields_by_name['python_param'].message_type = _PYTHONPARAMETER +_LAYERPARAMETER.fields_by_name['recurrent_param'].message_type = _RECURRENTPARAMETER +_LAYERPARAMETER.fields_by_name['reduction_param'].message_type = _REDUCTIONPARAMETER +_LAYERPARAMETER.fields_by_name['relu_param'].message_type = _RELUPARAMETER +_LAYERPARAMETER.fields_by_name['reshape_param'].message_type = _RESHAPEPARAMETER +_LAYERPARAMETER.fields_by_name['scale_param'].message_type = _SCALEPARAMETER +_LAYERPARAMETER.fields_by_name['sigmoid_param'].message_type = _SIGMOIDPARAMETER +_LAYERPARAMETER.fields_by_name['softmax_param'].message_type = _SOFTMAXPARAMETER +_LAYERPARAMETER.fields_by_name['spp_param'].message_type = _SPPPARAMETER +_LAYERPARAMETER.fields_by_name['slice_param'].message_type = _SLICEPARAMETER +_LAYERPARAMETER.fields_by_name['tanh_param'].message_type = _TANHPARAMETER +_LAYERPARAMETER.fields_by_name['threshold_param'].message_type = _THRESHOLDPARAMETER +_LAYERPARAMETER.fields_by_name['tile_param'].message_type = _TILEPARAMETER +_LAYERPARAMETER.fields_by_name['window_data_param'].message_type = _WINDOWDATAPARAMETER +_LAYERPARAMETER.fields_by_name['coeff_schedule_param'].message_type = _COEFFSCHEDULEPARAMETER +_LAYERPARAMETER.fields_by_name['augmentation_param'].message_type = _AUGMENTATIONPARAMETER +_LAYERPARAMETER.fields_by_name['correlation_param'].message_type = _CORRELATIONPARAMETER +_LAYERPARAMETER.fields_by_name['l1_loss_param'].message_type = _L1LOSSPARAMETER +_LAYERPARAMETER.fields_by_name['writer_param'].message_type = _WRITERPARAMETER +_LAYERPARAMETER.fields_by_name['reader_param'].message_type = _READERPARAMETER +_LAYERPARAMETER.fields_by_name['mean_param'].message_type = _MEANPARAMETER +_LAYERPARAMETER.fields_by_name['resample_param'].message_type = _RESAMPLEPARAMETER +_LAYERPARAMETER.fields_by_name['downsample_param'].message_type = _DOWNSAMPLEPARAMETER +_LAYERPARAMETER.fields_by_name['negsquare_param'].message_type = _NEGSQUAREPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['mirror'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['translate'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['rotate'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['zoom'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['squeeze'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['translate_x'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['translate_y'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['gamma'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['brightness'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['contrast'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['color'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['lmult_pow'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['lmult_mult'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['lmult_add'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['sat_pow'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['sat_mult'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['sat_add'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['col_pow'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['col_mult'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['col_add'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['ladd_pow'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['ladd_mult'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['ladd_add'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['col_rotate'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['fog_amount'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['fog_size'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['motion_blur_angle'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['motion_blur_size'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['shadow_angle'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['shadow_distance'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['shadow_strength'].message_type = _RANDOMGENERATORPARAMETER +_AUGMENTATIONPARAMETER.fields_by_name['noise'].message_type = _RANDOMGENERATORPARAMETER +_CORRELATIONPARAMETER.fields_by_name['correlation_type'].enum_type = _CORRELATIONPARAMETER_CORRELATIONTYPE +_CORRELATIONPARAMETER_CORRELATIONTYPE.containing_type = _CORRELATIONPARAMETER; +_RESAMPLEPARAMETER.fields_by_name['type'].enum_type = _RESAMPLEPARAMETER_RESAMPLETYPE +_RESAMPLEPARAMETER_RESAMPLETYPE.containing_type = _RESAMPLEPARAMETER; +_MEANPARAMETER.fields_by_name['operation'].enum_type = _MEANPARAMETER_MEANOPERATION +_MEANPARAMETER_MEANOPERATION.containing_type = _MEANPARAMETER; +_LOSSPARAMETER.fields_by_name['normalization'].enum_type = _LOSSPARAMETER_NORMALIZATIONMODE +_LOSSPARAMETER_NORMALIZATIONMODE.containing_type = _LOSSPARAMETER; +_BIASPARAMETER.fields_by_name['filler'].message_type = _FILLERPARAMETER +_CONVOLUTIONPARAMETER.fields_by_name['weight_filler'].message_type = _FILLERPARAMETER +_CONVOLUTIONPARAMETER.fields_by_name['bias_filler'].message_type = _FILLERPARAMETER +_CONVOLUTIONPARAMETER.fields_by_name['engine'].enum_type = _CONVOLUTIONPARAMETER_ENGINE +_CONVOLUTIONPARAMETER_ENGINE.containing_type = _CONVOLUTIONPARAMETER; +_DATAPARAMETER.fields_by_name['backend'].enum_type = _DATAPARAMETER_DB +_DATAPARAMETER.fields_by_name['rand_permute_order'].enum_type = _DATAPARAMETER_RANDPERMORDER +_DATAPARAMETER.fields_by_name['encoding'].enum_type = _DATAPARAMETER_CHANNELENCODING +_DATAPARAMETER_DB.containing_type = _DATAPARAMETER; +_DATAPARAMETER_CHANNELENCODING.containing_type = _DATAPARAMETER; +_DATAPARAMETER_RANDPERMORDER.containing_type = _DATAPARAMETER; +_DUMMYDATAPARAMETER.fields_by_name['data_filler'].message_type = _FILLERPARAMETER +_DUMMYDATAPARAMETER.fields_by_name['shape'].message_type = _BLOBSHAPE +_ELTWISEPARAMETER.fields_by_name['operation'].enum_type = _ELTWISEPARAMETER_ELTWISEOP +_ELTWISEPARAMETER_ELTWISEOP.containing_type = _ELTWISEPARAMETER; +_EMBEDPARAMETER.fields_by_name['weight_filler'].message_type = _FILLERPARAMETER +_EMBEDPARAMETER.fields_by_name['bias_filler'].message_type = _FILLERPARAMETER +_HINGELOSSPARAMETER.fields_by_name['norm'].enum_type = _HINGELOSSPARAMETER_NORM +_HINGELOSSPARAMETER_NORM.containing_type = _HINGELOSSPARAMETER; +_INNERPRODUCTPARAMETER.fields_by_name['weight_filler'].message_type = _FILLERPARAMETER +_INNERPRODUCTPARAMETER.fields_by_name['bias_filler'].message_type = _FILLERPARAMETER +_INPUTPARAMETER.fields_by_name['shape'].message_type = _BLOBSHAPE +_LRNPARAMETER.fields_by_name['norm_region'].enum_type = _LRNPARAMETER_NORMREGION +_LRNPARAMETER.fields_by_name['engine'].enum_type = _LRNPARAMETER_ENGINE +_LRNPARAMETER_NORMREGION.containing_type = _LRNPARAMETER; +_LRNPARAMETER_ENGINE.containing_type = _LRNPARAMETER; +_PARAMETERPARAMETER.fields_by_name['shape'].message_type = _BLOBSHAPE +_POOLINGPARAMETER.fields_by_name['pool'].enum_type = _POOLINGPARAMETER_POOLMETHOD +_POOLINGPARAMETER.fields_by_name['engine'].enum_type = _POOLINGPARAMETER_ENGINE +_POOLINGPARAMETER_POOLMETHOD.containing_type = _POOLINGPARAMETER; +_POOLINGPARAMETER_ENGINE.containing_type = _POOLINGPARAMETER; +_RECURRENTPARAMETER.fields_by_name['weight_filler'].message_type = _FILLERPARAMETER +_RECURRENTPARAMETER.fields_by_name['bias_filler'].message_type = _FILLERPARAMETER +_REDUCTIONPARAMETER.fields_by_name['operation'].enum_type = _REDUCTIONPARAMETER_REDUCTIONOP +_REDUCTIONPARAMETER_REDUCTIONOP.containing_type = _REDUCTIONPARAMETER; +_RELUPARAMETER.fields_by_name['engine'].enum_type = _RELUPARAMETER_ENGINE +_RELUPARAMETER_ENGINE.containing_type = _RELUPARAMETER; +_RESHAPEPARAMETER.fields_by_name['shape'].message_type = _BLOBSHAPE +_SCALEPARAMETER.fields_by_name['filler'].message_type = _FILLERPARAMETER +_SCALEPARAMETER.fields_by_name['bias_filler'].message_type = _FILLERPARAMETER +_SIGMOIDPARAMETER.fields_by_name['engine'].enum_type = _SIGMOIDPARAMETER_ENGINE +_SIGMOIDPARAMETER_ENGINE.containing_type = _SIGMOIDPARAMETER; +_SOFTMAXPARAMETER.fields_by_name['engine'].enum_type = _SOFTMAXPARAMETER_ENGINE +_SOFTMAXPARAMETER_ENGINE.containing_type = _SOFTMAXPARAMETER; +_TANHPARAMETER.fields_by_name['engine'].enum_type = _TANHPARAMETER_ENGINE +_TANHPARAMETER_ENGINE.containing_type = _TANHPARAMETER; +_SPPPARAMETER.fields_by_name['pool'].enum_type = _SPPPARAMETER_POOLMETHOD +_SPPPARAMETER.fields_by_name['engine'].enum_type = _SPPPARAMETER_ENGINE +_SPPPARAMETER_POOLMETHOD.containing_type = _SPPPARAMETER; +_SPPPARAMETER_ENGINE.containing_type = _SPPPARAMETER; +_V1LAYERPARAMETER.fields_by_name['include'].message_type = _NETSTATERULE +_V1LAYERPARAMETER.fields_by_name['exclude'].message_type = _NETSTATERULE +_V1LAYERPARAMETER.fields_by_name['type'].enum_type = _V1LAYERPARAMETER_LAYERTYPE +_V1LAYERPARAMETER.fields_by_name['blobs'].message_type = _BLOBPROTO +_V1LAYERPARAMETER.fields_by_name['blob_share_mode'].enum_type = _V1LAYERPARAMETER_DIMCHECKMODE +_V1LAYERPARAMETER.fields_by_name['accuracy_param'].message_type = _ACCURACYPARAMETER +_V1LAYERPARAMETER.fields_by_name['argmax_param'].message_type = _ARGMAXPARAMETER +_V1LAYERPARAMETER.fields_by_name['concat_param'].message_type = _CONCATPARAMETER +_V1LAYERPARAMETER.fields_by_name['contrastive_loss_param'].message_type = _CONTRASTIVELOSSPARAMETER +_V1LAYERPARAMETER.fields_by_name['convolution_param'].message_type = _CONVOLUTIONPARAMETER +_V1LAYERPARAMETER.fields_by_name['data_param'].message_type = _DATAPARAMETER +_V1LAYERPARAMETER.fields_by_name['dropout_param'].message_type = _DROPOUTPARAMETER +_V1LAYERPARAMETER.fields_by_name['dummy_data_param'].message_type = _DUMMYDATAPARAMETER +_V1LAYERPARAMETER.fields_by_name['eltwise_param'].message_type = _ELTWISEPARAMETER +_V1LAYERPARAMETER.fields_by_name['exp_param'].message_type = _EXPPARAMETER +_V1LAYERPARAMETER.fields_by_name['hdf5_data_param'].message_type = _HDF5DATAPARAMETER +_V1LAYERPARAMETER.fields_by_name['hdf5_output_param'].message_type = _HDF5OUTPUTPARAMETER +_V1LAYERPARAMETER.fields_by_name['hinge_loss_param'].message_type = _HINGELOSSPARAMETER +_V1LAYERPARAMETER.fields_by_name['image_data_param'].message_type = _IMAGEDATAPARAMETER +_V1LAYERPARAMETER.fields_by_name['infogain_loss_param'].message_type = _INFOGAINLOSSPARAMETER +_V1LAYERPARAMETER.fields_by_name['inner_product_param'].message_type = _INNERPRODUCTPARAMETER +_V1LAYERPARAMETER.fields_by_name['lrn_param'].message_type = _LRNPARAMETER +_V1LAYERPARAMETER.fields_by_name['memory_data_param'].message_type = _MEMORYDATAPARAMETER +_V1LAYERPARAMETER.fields_by_name['mvn_param'].message_type = _MVNPARAMETER +_V1LAYERPARAMETER.fields_by_name['pooling_param'].message_type = _POOLINGPARAMETER +_V1LAYERPARAMETER.fields_by_name['power_param'].message_type = _POWERPARAMETER +_V1LAYERPARAMETER.fields_by_name['relu_param'].message_type = _RELUPARAMETER +_V1LAYERPARAMETER.fields_by_name['sigmoid_param'].message_type = _SIGMOIDPARAMETER +_V1LAYERPARAMETER.fields_by_name['softmax_param'].message_type = _SOFTMAXPARAMETER +_V1LAYERPARAMETER.fields_by_name['slice_param'].message_type = _SLICEPARAMETER +_V1LAYERPARAMETER.fields_by_name['tanh_param'].message_type = _TANHPARAMETER +_V1LAYERPARAMETER.fields_by_name['threshold_param'].message_type = _THRESHOLDPARAMETER +_V1LAYERPARAMETER.fields_by_name['window_data_param'].message_type = _WINDOWDATAPARAMETER +_V1LAYERPARAMETER.fields_by_name['transform_param'].message_type = _TRANSFORMATIONPARAMETER +_V1LAYERPARAMETER.fields_by_name['loss_param'].message_type = _LOSSPARAMETER +_V1LAYERPARAMETER.fields_by_name['layer'].message_type = _V0LAYERPARAMETER +_V1LAYERPARAMETER_LAYERTYPE.containing_type = _V1LAYERPARAMETER; +_V1LAYERPARAMETER_DIMCHECKMODE.containing_type = _V1LAYERPARAMETER; +_V0LAYERPARAMETER.fields_by_name['weight_filler'].message_type = _FILLERPARAMETER +_V0LAYERPARAMETER.fields_by_name['bias_filler'].message_type = _FILLERPARAMETER +_V0LAYERPARAMETER.fields_by_name['pool'].enum_type = _V0LAYERPARAMETER_POOLMETHOD +_V0LAYERPARAMETER.fields_by_name['blobs'].message_type = _BLOBPROTO +_V0LAYERPARAMETER.fields_by_name['hdf5_output_param'].message_type = _HDF5OUTPUTPARAMETER +_V0LAYERPARAMETER_POOLMETHOD.containing_type = _V0LAYERPARAMETER; +_PRELUPARAMETER.fields_by_name['filler'].message_type = _FILLERPARAMETER +DESCRIPTOR.message_types_by_name['BlobShape'] = _BLOBSHAPE +DESCRIPTOR.message_types_by_name['BlobProto'] = _BLOBPROTO +DESCRIPTOR.message_types_by_name['BlobProtoVector'] = _BLOBPROTOVECTOR +DESCRIPTOR.message_types_by_name['Datum'] = _DATUM +DESCRIPTOR.message_types_by_name['FillerParameter'] = _FILLERPARAMETER +DESCRIPTOR.message_types_by_name['NetParameter'] = _NETPARAMETER +DESCRIPTOR.message_types_by_name['SolverParameter'] = _SOLVERPARAMETER +DESCRIPTOR.message_types_by_name['SolverState'] = _SOLVERSTATE +DESCRIPTOR.message_types_by_name['NetState'] = _NETSTATE +DESCRIPTOR.message_types_by_name['NetStateRule'] = _NETSTATERULE +DESCRIPTOR.message_types_by_name['ParamSpec'] = _PARAMSPEC +DESCRIPTOR.message_types_by_name['LayerParameter'] = _LAYERPARAMETER +DESCRIPTOR.message_types_by_name['GridParameter'] = _GRIDPARAMETER +DESCRIPTOR.message_types_by_name['AugmentationCoeff'] = _AUGMENTATIONCOEFF +DESCRIPTOR.message_types_by_name['AugmentationParameter'] = _AUGMENTATIONPARAMETER +DESCRIPTOR.message_types_by_name['RandomGeneratorParameter'] = _RANDOMGENERATORPARAMETER +DESCRIPTOR.message_types_by_name['L1LossParameter'] = _L1LOSSPARAMETER +DESCRIPTOR.message_types_by_name['CorrelationParameter'] = _CORRELATIONPARAMETER +DESCRIPTOR.message_types_by_name['DownsampleParameter'] = _DOWNSAMPLEPARAMETER +DESCRIPTOR.message_types_by_name['ReaderParameter'] = _READERPARAMETER +DESCRIPTOR.message_types_by_name['WriterParameter'] = _WRITERPARAMETER +DESCRIPTOR.message_types_by_name['ResampleParameter'] = _RESAMPLEPARAMETER +DESCRIPTOR.message_types_by_name['MeanParameter'] = _MEANPARAMETER +DESCRIPTOR.message_types_by_name['CoeffScheduleParameter'] = _COEFFSCHEDULEPARAMETER +DESCRIPTOR.message_types_by_name['TransformationParameter'] = _TRANSFORMATIONPARAMETER +DESCRIPTOR.message_types_by_name['LossParameter'] = _LOSSPARAMETER +DESCRIPTOR.message_types_by_name['AccuracyParameter'] = _ACCURACYPARAMETER +DESCRIPTOR.message_types_by_name['ArgMaxParameter'] = _ARGMAXPARAMETER +DESCRIPTOR.message_types_by_name['ConcatParameter'] = _CONCATPARAMETER +DESCRIPTOR.message_types_by_name['BatchNormParameter'] = _BATCHNORMPARAMETER +DESCRIPTOR.message_types_by_name['BiasParameter'] = _BIASPARAMETER +DESCRIPTOR.message_types_by_name['ContrastiveLossParameter'] = _CONTRASTIVELOSSPARAMETER +DESCRIPTOR.message_types_by_name['ConvolutionParameter'] = _CONVOLUTIONPARAMETER +DESCRIPTOR.message_types_by_name['CropParameter'] = _CROPPARAMETER +DESCRIPTOR.message_types_by_name['DataParameter'] = _DATAPARAMETER +DESCRIPTOR.message_types_by_name['DropoutParameter'] = _DROPOUTPARAMETER +DESCRIPTOR.message_types_by_name['DummyDataParameter'] = _DUMMYDATAPARAMETER +DESCRIPTOR.message_types_by_name['EltwiseParameter'] = _ELTWISEPARAMETER +DESCRIPTOR.message_types_by_name['ELUParameter'] = _ELUPARAMETER +DESCRIPTOR.message_types_by_name['EmbedParameter'] = _EMBEDPARAMETER +DESCRIPTOR.message_types_by_name['ExpParameter'] = _EXPPARAMETER +DESCRIPTOR.message_types_by_name['ExpMaxParameter'] = _EXPMAXPARAMETER +DESCRIPTOR.message_types_by_name['FlattenParameter'] = _FLATTENPARAMETER +DESCRIPTOR.message_types_by_name['HDF5DataParameter'] = _HDF5DATAPARAMETER +DESCRIPTOR.message_types_by_name['HDF5OutputParameter'] = _HDF5OUTPUTPARAMETER +DESCRIPTOR.message_types_by_name['HingeLossParameter'] = _HINGELOSSPARAMETER +DESCRIPTOR.message_types_by_name['ImageDataParameter'] = _IMAGEDATAPARAMETER +DESCRIPTOR.message_types_by_name['InfogainLossParameter'] = _INFOGAINLOSSPARAMETER +DESCRIPTOR.message_types_by_name['InnerProductParameter'] = _INNERPRODUCTPARAMETER +DESCRIPTOR.message_types_by_name['InputParameter'] = _INPUTPARAMETER +DESCRIPTOR.message_types_by_name['LogParameter'] = _LOGPARAMETER +DESCRIPTOR.message_types_by_name['LRNParameter'] = _LRNPARAMETER +DESCRIPTOR.message_types_by_name['MemoryDataParameter'] = _MEMORYDATAPARAMETER +DESCRIPTOR.message_types_by_name['MVNParameter'] = _MVNPARAMETER +DESCRIPTOR.message_types_by_name['ParameterParameter'] = _PARAMETERPARAMETER +DESCRIPTOR.message_types_by_name['PoolingParameter'] = _POOLINGPARAMETER +DESCRIPTOR.message_types_by_name['PowerParameter'] = _POWERPARAMETER +DESCRIPTOR.message_types_by_name['NegSquareParameter'] = _NEGSQUAREPARAMETER +DESCRIPTOR.message_types_by_name['PythonParameter'] = _PYTHONPARAMETER +DESCRIPTOR.message_types_by_name['RecurrentParameter'] = _RECURRENTPARAMETER +DESCRIPTOR.message_types_by_name['ReductionParameter'] = _REDUCTIONPARAMETER +DESCRIPTOR.message_types_by_name['ReLUParameter'] = _RELUPARAMETER +DESCRIPTOR.message_types_by_name['ReshapeParameter'] = _RESHAPEPARAMETER +DESCRIPTOR.message_types_by_name['ScaleParameter'] = _SCALEPARAMETER +DESCRIPTOR.message_types_by_name['SigmoidParameter'] = _SIGMOIDPARAMETER +DESCRIPTOR.message_types_by_name['SliceParameter'] = _SLICEPARAMETER +DESCRIPTOR.message_types_by_name['SoftmaxParameter'] = _SOFTMAXPARAMETER +DESCRIPTOR.message_types_by_name['TanHParameter'] = _TANHPARAMETER +DESCRIPTOR.message_types_by_name['TileParameter'] = _TILEPARAMETER +DESCRIPTOR.message_types_by_name['ThresholdParameter'] = _THRESHOLDPARAMETER +DESCRIPTOR.message_types_by_name['WindowDataParameter'] = _WINDOWDATAPARAMETER +DESCRIPTOR.message_types_by_name['SPPParameter'] = _SPPPARAMETER +DESCRIPTOR.message_types_by_name['V1LayerParameter'] = _V1LAYERPARAMETER +DESCRIPTOR.message_types_by_name['V0LayerParameter'] = _V0LAYERPARAMETER +DESCRIPTOR.message_types_by_name['PReLUParameter'] = _PRELUPARAMETER + +class BlobShape(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _BLOBSHAPE + + # @@protoc_insertion_point(class_scope:caffe.BlobShape) + +class BlobProto(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _BLOBPROTO + + # @@protoc_insertion_point(class_scope:caffe.BlobProto) + +class BlobProtoVector(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _BLOBPROTOVECTOR + + # @@protoc_insertion_point(class_scope:caffe.BlobProtoVector) + +class Datum(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _DATUM + + # @@protoc_insertion_point(class_scope:caffe.Datum) + +class FillerParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _FILLERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.FillerParameter) + +class NetParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _NETPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.NetParameter) + +class SolverParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SOLVERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.SolverParameter) + +class SolverState(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SOLVERSTATE + + # @@protoc_insertion_point(class_scope:caffe.SolverState) + +class NetState(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _NETSTATE + + # @@protoc_insertion_point(class_scope:caffe.NetState) + +class NetStateRule(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _NETSTATERULE + + # @@protoc_insertion_point(class_scope:caffe.NetStateRule) + +class ParamSpec(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _PARAMSPEC + + # @@protoc_insertion_point(class_scope:caffe.ParamSpec) + +class LayerParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _LAYERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.LayerParameter) + +class GridParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _GRIDPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.GridParameter) + +class AugmentationCoeff(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _AUGMENTATIONCOEFF + + # @@protoc_insertion_point(class_scope:caffe.AugmentationCoeff) + +class AugmentationParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _AUGMENTATIONPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.AugmentationParameter) + +class RandomGeneratorParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _RANDOMGENERATORPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.RandomGeneratorParameter) + +class L1LossParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _L1LOSSPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.L1LossParameter) + +class CorrelationParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CORRELATIONPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.CorrelationParameter) + +class DownsampleParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _DOWNSAMPLEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.DownsampleParameter) + +class ReaderParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _READERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ReaderParameter) + +class WriterParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _WRITERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.WriterParameter) + +class ResampleParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _RESAMPLEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ResampleParameter) + +class MeanParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _MEANPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.MeanParameter) + +class CoeffScheduleParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _COEFFSCHEDULEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.CoeffScheduleParameter) + +class TransformationParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _TRANSFORMATIONPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.TransformationParameter) + +class LossParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _LOSSPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.LossParameter) + +class AccuracyParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _ACCURACYPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.AccuracyParameter) + +class ArgMaxParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _ARGMAXPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ArgMaxParameter) + +class ConcatParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CONCATPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ConcatParameter) + +class BatchNormParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _BATCHNORMPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.BatchNormParameter) + +class BiasParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _BIASPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.BiasParameter) + +class ContrastiveLossParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CONTRASTIVELOSSPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ContrastiveLossParameter) + +class ConvolutionParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CONVOLUTIONPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ConvolutionParameter) + +class CropParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CROPPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.CropParameter) + +class DataParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _DATAPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.DataParameter) + +class DropoutParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _DROPOUTPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.DropoutParameter) + +class DummyDataParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _DUMMYDATAPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.DummyDataParameter) + +class EltwiseParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _ELTWISEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.EltwiseParameter) + +class ELUParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _ELUPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ELUParameter) + +class EmbedParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _EMBEDPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.EmbedParameter) + +class ExpParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _EXPPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ExpParameter) + +class ExpMaxParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _EXPMAXPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ExpMaxParameter) + +class FlattenParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _FLATTENPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.FlattenParameter) + +class HDF5DataParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _HDF5DATAPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.HDF5DataParameter) + +class HDF5OutputParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _HDF5OUTPUTPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.HDF5OutputParameter) + +class HingeLossParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _HINGELOSSPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.HingeLossParameter) + +class ImageDataParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _IMAGEDATAPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ImageDataParameter) + +class InfogainLossParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _INFOGAINLOSSPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.InfogainLossParameter) + +class InnerProductParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _INNERPRODUCTPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.InnerProductParameter) + +class InputParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _INPUTPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.InputParameter) + +class LogParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _LOGPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.LogParameter) + +class LRNParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _LRNPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.LRNParameter) + +class MemoryDataParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _MEMORYDATAPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.MemoryDataParameter) + +class MVNParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _MVNPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.MVNParameter) + +class ParameterParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _PARAMETERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ParameterParameter) + +class PoolingParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _POOLINGPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.PoolingParameter) + +class PowerParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _POWERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.PowerParameter) + +class NegSquareParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _NEGSQUAREPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.NegSquareParameter) + +class PythonParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _PYTHONPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.PythonParameter) + +class RecurrentParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _RECURRENTPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.RecurrentParameter) + +class ReductionParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _REDUCTIONPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ReductionParameter) + +class ReLUParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _RELUPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ReLUParameter) + +class ReshapeParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _RESHAPEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ReshapeParameter) + +class ScaleParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SCALEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ScaleParameter) + +class SigmoidParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SIGMOIDPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.SigmoidParameter) + +class SliceParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SLICEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.SliceParameter) + +class SoftmaxParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SOFTMAXPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.SoftmaxParameter) + +class TanHParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _TANHPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.TanHParameter) + +class TileParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _TILEPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.TileParameter) + +class ThresholdParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _THRESHOLDPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.ThresholdParameter) + +class WindowDataParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _WINDOWDATAPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.WindowDataParameter) + +class SPPParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SPPPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.SPPParameter) + +class V1LayerParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _V1LAYERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.V1LayerParameter) + +class V0LayerParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _V0LAYERPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.V0LayerParameter) + +class PReLUParameter(_message.Message): + __metaclass__ = _reflection.GeneratedProtocolMessageType + DESCRIPTOR = _PRELUPARAMETER + + # @@protoc_insertion_point(class_scope:caffe.PReLUParameter) + + +_BLOBSHAPE.fields_by_name['dim'].has_options = True +_BLOBSHAPE.fields_by_name['dim']._options = _descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001') +_BLOBPROTO.fields_by_name['data'].has_options = True +_BLOBPROTO.fields_by_name['data']._options = _descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001') +_BLOBPROTO.fields_by_name['diff'].has_options = True +_BLOBPROTO.fields_by_name['diff']._options = _descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001') +_BLOBPROTO.fields_by_name['double_data'].has_options = True +_BLOBPROTO.fields_by_name['double_data']._options = _descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001') +_BLOBPROTO.fields_by_name['double_diff'].has_options = True +_BLOBPROTO.fields_by_name['double_diff']._options = _descriptor._ParseOptions(descriptor_pb2.FieldOptions(), '\020\001') +# @@protoc_insertion_point(module_scope) diff --git a/python/caffe/pycaffe.py b/python/caffe/pycaffe.py new file mode 100644 index 0000000..ca6d050 --- /dev/null +++ b/python/caffe/pycaffe.py @@ -0,0 +1,324 @@ +""" +Wrap the internal caffe C++ module (_caffe.so) with a clean, Pythonic +interface. +""" + +from collections import OrderedDict +try: + from itertools import izip_longest +except: + from itertools import zip_longest as izip_longest +import numpy as np + +from ._caffe import Net, SGDSolver, NesterovSolver, AdaGradSolver, \ + RMSPropSolver, AdaDeltaSolver, AdamSolver +import caffe.io + +import six + +# We directly update methods from Net here (rather than using composition or +# inheritance) so that nets created by caffe (e.g., by SGDSolver) will +# automatically have the improved interface. + + +@property +def _Net_blobs(self): + """ + An OrderedDict (bottom to top, i.e., input to output) of network + blobs indexed by name + """ + if not hasattr(self, '_blobs_dict'): + self._blobs_dict = OrderedDict(zip(self._blob_names, self._blobs)) + return self._blobs_dict + + +@property +def _Net_blob_loss_weights(self): + """ + An OrderedDict (bottom to top, i.e., input to output) of network + blob loss weights indexed by name + """ + if not hasattr(self, '_blobs_loss_weights_dict'): + self._blob_loss_weights_dict = OrderedDict(zip(self._blob_names, + self._blob_loss_weights)) + return self._blob_loss_weights_dict + + +@property +def _Net_params(self): + """ + An OrderedDict (bottom to top, i.e., input to output) of network + parameters indexed by name; each is a list of multiple blobs (e.g., + weights and biases) + """ + if not hasattr(self, '_params_dict'): + self._params_dict = OrderedDict([(name, lr.blobs) + for name, lr in zip( + self._layer_names, self.layers) + if len(lr.blobs) > 0]) + return self._params_dict + + +@property +def _Net_inputs(self): + if not hasattr(self, '_input_list'): + keys = list(self.blobs.keys()) + self._input_list = [keys[i] for i in self._inputs] + return self._input_list + + +@property +def _Net_outputs(self): + if not hasattr(self, '_output_list'): + keys = list(self.blobs.keys()) + self._output_list = [keys[i] for i in self._outputs] + return self._output_list + + +def _Net_forward(self, blobs=None, start=None, end=None, **kwargs): + """ + Forward pass: prepare inputs and run the net forward. + + Parameters + ---------- + blobs : list of blobs to return in addition to output blobs. + kwargs : Keys are input blob names and values are blob ndarrays. + For formatting inputs for Caffe, see Net.preprocess(). + If None, input is taken from data layers. + start : optional name of layer at which to begin the forward pass + end : optional name of layer at which to finish the forward pass + (inclusive) + + Returns + ------- + outs : {blob name: blob ndarray} dict. + """ + if blobs is None: + blobs = [] + + if start is not None: + start_ind = list(self._layer_names).index(start) + else: + start_ind = 0 + + if end is not None: + end_ind = list(self._layer_names).index(end) + outputs = set([end] + blobs) + else: + end_ind = len(self.layers) - 1 + outputs = set(self.outputs + blobs) + + if kwargs: + if set(kwargs.keys()) != set(self.inputs): + raise Exception('Input blob arguments do not match net inputs.') + # Set input according to defined shapes and make arrays single and + # C-contiguous as Caffe expects. + for in_, blob in six.iteritems(kwargs): + if blob.shape[0] != self.blobs[in_].shape[0]: + raise Exception('Input is not batch sized') + self.blobs[in_].data[...] = blob + + self._forward(start_ind, end_ind) + + # Unpack blobs to extract + return {out: self.blobs[out].data for out in outputs} + + +def _Net_backward(self, diffs=None, start=None, end=None, **kwargs): + """ + Backward pass: prepare diffs and run the net backward. + + Parameters + ---------- + diffs : list of diffs to return in addition to bottom diffs. + kwargs : Keys are output blob names and values are diff ndarrays. + If None, top diffs are taken from forward loss. + start : optional name of layer at which to begin the backward pass + end : optional name of layer at which to finish the backward pass + (inclusive) + + Returns + ------- + outs: {blob name: diff ndarray} dict. + """ + if diffs is None: + diffs = [] + + if start is not None: + start_ind = list(self._layer_names).index(start) + else: + start_ind = len(self.layers) - 1 + + if end is not None: + end_ind = list(self._layer_names).index(end) + outputs = set([end] + diffs) + else: + end_ind = 0 + outputs = set(self.inputs + diffs) + + if kwargs: + if set(kwargs.keys()) != set(self.outputs): + raise Exception('Top diff arguments do not match net outputs.') + # Set top diffs according to defined shapes and make arrays single and + # C-contiguous as Caffe expects. + for top, diff in six.iteritems(kwargs): + if diff.shape[0] != self.blobs[top].shape[0]: + raise Exception('Diff is not batch sized') + self.blobs[top].diff[...] = diff + + self._backward(start_ind, end_ind) + + # Unpack diffs to extract + return {out: self.blobs[out].diff for out in outputs} + + +def _Net_forward_all(self, blobs=None, **kwargs): + """ + Run net forward in batches. + + Parameters + ---------- + blobs : list of blobs to extract as in forward() + kwargs : Keys are input blob names and values are blob ndarrays. + Refer to forward(). + + Returns + ------- + all_outs : {blob name: list of blobs} dict. + """ + # Collect outputs from batches + all_outs = {out: [] for out in set(self.outputs + (blobs or []))} + for batch in self._batch(kwargs): + outs = self.forward(blobs=blobs, **batch) + for out, out_blob in six.iteritems(outs): + all_outs[out].extend(out_blob.copy()) + # Package in ndarray. + for out in all_outs: + all_outs[out] = np.asarray(all_outs[out]) + # Discard padding. + pad = len(six.next(six.itervalues(all_outs))) - len(six.next(six.itervalues(kwargs))) + if pad: + for out in all_outs: + all_outs[out] = all_outs[out][:-pad] + return all_outs + + +def _Net_forward_backward_all(self, blobs=None, diffs=None, **kwargs): + """ + Run net forward + backward in batches. + + Parameters + ---------- + blobs: list of blobs to extract as in forward() + diffs: list of diffs to extract as in backward() + kwargs: Keys are input (for forward) and output (for backward) blob names + and values are ndarrays. Refer to forward() and backward(). + Prefilled variants are called for lack of input or output blobs. + + Returns + ------- + all_blobs: {blob name: blob ndarray} dict. + all_diffs: {blob name: diff ndarray} dict. + """ + # Batch blobs and diffs. + all_outs = {out: [] for out in set(self.outputs + (blobs or []))} + all_diffs = {diff: [] for diff in set(self.inputs + (diffs or []))} + forward_batches = self._batch({in_: kwargs[in_] + for in_ in self.inputs if in_ in kwargs}) + backward_batches = self._batch({out: kwargs[out] + for out in self.outputs if out in kwargs}) + # Collect outputs from batches (and heed lack of forward/backward batches). + for fb, bb in izip_longest(forward_batches, backward_batches, fillvalue={}): + batch_blobs = self.forward(blobs=blobs, **fb) + batch_diffs = self.backward(diffs=diffs, **bb) + for out, out_blobs in six.iteritems(batch_blobs): + all_outs[out].extend(out_blobs.copy()) + for diff, out_diffs in six.iteritems(batch_diffs): + all_diffs[diff].extend(out_diffs.copy()) + # Package in ndarray. + for out, diff in zip(all_outs, all_diffs): + all_outs[out] = np.asarray(all_outs[out]) + all_diffs[diff] = np.asarray(all_diffs[diff]) + # Discard padding at the end and package in ndarray. + pad = len(six.next(six.itervalues(all_outs))) - len(six.next(six.itervalues(kwargs))) + if pad: + for out, diff in zip(all_outs, all_diffs): + all_outs[out] = all_outs[out][:-pad] + all_diffs[diff] = all_diffs[diff][:-pad] + return all_outs, all_diffs + + +def _Net_set_input_arrays(self, data, labels): + """ + Set input arrays of the in-memory MemoryDataLayer. + (Note: this is only for networks declared with the memory data layer.) + """ + if labels.ndim == 1: + labels = np.ascontiguousarray(labels[:, np.newaxis, np.newaxis, + np.newaxis]) + return self._set_input_arrays(data, labels) + + +def _Net_batch(self, blobs): + """ + Batch blob lists according to net's batch size. + + Parameters + ---------- + blobs: Keys blob names and values are lists of blobs (of any length). + Naturally, all the lists should have the same length. + + Yields + ------ + batch: {blob name: list of blobs} dict for a single batch. + """ + num = len(six.next(six.itervalues(blobs))) + batch_size = six.next(six.itervalues(self.blobs)).shape[0] + remainder = num % batch_size + num_batches = num // batch_size + + # Yield full batches. + for b in range(num_batches): + i = b * batch_size + yield {name: blobs[name][i:i + batch_size] for name in blobs} + + # Yield last padded batch, if any. + if remainder > 0: + padded_batch = {} + for name in blobs: + padding = np.zeros((batch_size - remainder,) + + blobs[name].shape[1:]) + padded_batch[name] = np.concatenate([blobs[name][-remainder:], + padding]) + yield padded_batch + + +class _Net_IdNameWrapper: + """ + A simple wrapper that allows the ids propery to be accessed as a dict + indexed by names. Used for top and bottom names + """ + def __init__(self, net, func): + self.net, self.func = net, func + + def __getitem__(self, name): + # Map the layer name to id + ids = self.func(self.net, list(self.net._layer_names).index(name)) + # Map the blob id to name + id_to_name = list(self.net.blobs) + return [id_to_name[i] for i in ids] + +# Attach methods to Net. +Net.blobs = _Net_blobs +Net.blob_loss_weights = _Net_blob_loss_weights +Net.params = _Net_params +Net.forward = _Net_forward +Net.backward = _Net_backward +Net.forward_all = _Net_forward_all +Net.forward_backward_all = _Net_forward_backward_all +Net.set_input_arrays = _Net_set_input_arrays +Net._batch = _Net_batch +Net.inputs = _Net_inputs +Net.outputs = _Net_outputs +Net.top_names = property(lambda n: _Net_IdNameWrapper(n, Net._top_ids)) +Net.bottom_names = property(lambda n: _Net_IdNameWrapper(n, Net._bottom_ids)) diff --git a/python/caffe/pycaffe.pyc b/python/caffe/pycaffe.pyc new file mode 100644 index 0000000..c5d47c2 Binary files /dev/null and b/python/caffe/pycaffe.pyc differ diff --git a/python/caffe/test/test_coord_map.py b/python/caffe/test/test_coord_map.py new file mode 100644 index 0000000..613260e --- /dev/null +++ b/python/caffe/test/test_coord_map.py @@ -0,0 +1,192 @@ +import unittest + +import numpy as np +import random + +import caffe +from caffe import layers as L +from caffe import params as P +from caffe.coord_map import coord_map_from_to, crop + + +def coord_net_spec(ks=3, stride=1, pad=0, pool=2, dstride=2, dpad=0): + """ + Define net spec for simple conv-pool-deconv pattern common to all + coordinate mapping tests. + """ + n = caffe.NetSpec() + n.data = L.Input(shape=dict(dim=[2, 1, 100, 100])) + n.aux = L.Input(shape=dict(dim=[2, 1, 20, 20])) + n.conv = L.Convolution( + n.data, num_output=10, kernel_size=ks, stride=stride, pad=pad) + n.pool = L.Pooling( + n.conv, pool=P.Pooling.MAX, kernel_size=pool, stride=pool, pad=0) + # for upsampling kernel size is 2x stride + try: + deconv_ks = [s*2 for s in dstride] + except: + deconv_ks = dstride*2 + n.deconv = L.Deconvolution( + n.pool, num_output=10, kernel_size=deconv_ks, stride=dstride, pad=dpad) + return n + + +class TestCoordMap(unittest.TestCase): + def setUp(self): + pass + + def test_conv_pool_deconv(self): + """ + Map through conv, pool, and deconv. + """ + n = coord_net_spec() + # identity for 2x pool, 2x deconv + ax, a, b = coord_map_from_to(n.deconv, n.data) + self.assertEquals(ax, 1) + self.assertEquals(a, 1) + self.assertEquals(b, 0) + # shift-by-one for 4x pool, 4x deconv + n = coord_net_spec(pool=4, dstride=4) + ax, a, b = coord_map_from_to(n.deconv, n.data) + self.assertEquals(ax, 1) + self.assertEquals(a, 1) + self.assertEquals(b, -1) + + def test_pass(self): + """ + A pass-through layer (ReLU) and conv (1x1, stride 1, pad 0) + both do identity mapping. + """ + n = coord_net_spec() + ax, a, b = coord_map_from_to(n.deconv, n.data) + n.relu = L.ReLU(n.deconv) + n.conv1x1 = L.Convolution( + n.relu, num_output=10, kernel_size=1, stride=1, pad=0) + for top in [n.relu, n.conv1x1]: + ax_pass, a_pass, b_pass = coord_map_from_to(top, n.data) + self.assertEquals(ax, ax_pass) + self.assertEquals(a, a_pass) + self.assertEquals(b, b_pass) + + def test_padding(self): + """ + Padding conv adds offset while padding deconv subtracts offset. + """ + n = coord_net_spec() + ax, a, b = coord_map_from_to(n.deconv, n.data) + pad = random.randint(0, 10) + # conv padding + n = coord_net_spec(pad=pad) + _, a_pad, b_pad = coord_map_from_to(n.deconv, n.data) + self.assertEquals(a, a_pad) + self.assertEquals(b - pad, b_pad) + # deconv padding + n = coord_net_spec(dpad=pad) + _, a_pad, b_pad = coord_map_from_to(n.deconv, n.data) + self.assertEquals(a, a_pad) + self.assertEquals(b + pad, b_pad) + # pad both to cancel out + n = coord_net_spec(pad=pad, dpad=pad) + _, a_pad, b_pad = coord_map_from_to(n.deconv, n.data) + self.assertEquals(a, a_pad) + self.assertEquals(b, b_pad) + + def test_multi_conv(self): + """ + Multiple bottoms/tops of a layer are identically mapped. + """ + n = coord_net_spec() + # multi bottom/top + n.conv_data, n.conv_aux = L.Convolution( + n.data, n.aux, ntop=2, num_output=10, kernel_size=5, stride=2, + pad=0) + ax1, a1, b1 = coord_map_from_to(n.conv_data, n.data) + ax2, a2, b2 = coord_map_from_to(n.conv_aux, n.aux) + self.assertEquals(ax1, ax2) + self.assertEquals(a1, a2) + self.assertEquals(b1, b2) + + def test_rect(self): + """ + Anisotropic mapping is equivalent to its isotropic parts. + """ + n3x3 = coord_net_spec(ks=3, stride=1, pad=0) + n5x5 = coord_net_spec(ks=5, stride=2, pad=10) + n3x5 = coord_net_spec(ks=[3, 5], stride=[1, 2], pad=[0, 10]) + ax_3x3, a_3x3, b_3x3 = coord_map_from_to(n3x3.deconv, n3x3.data) + ax_5x5, a_5x5, b_5x5 = coord_map_from_to(n5x5.deconv, n5x5.data) + ax_3x5, a_3x5, b_3x5 = coord_map_from_to(n3x5.deconv, n3x5.data) + self.assertTrue(ax_3x3 == ax_5x5 == ax_3x5) + self.assertEquals(a_3x3, a_3x5[0]) + self.assertEquals(b_3x3, b_3x5[0]) + self.assertEquals(a_5x5, a_3x5[1]) + self.assertEquals(b_5x5, b_3x5[1]) + + def test_nd_conv(self): + """ + ND conv maps the same way in more dimensions. + """ + n = caffe.NetSpec() + # define data with 3 spatial dimensions, otherwise the same net + n.data = L.Input(shape=dict(dim=[2, 3, 100, 100, 100])) + n.conv = L.Convolution( + n.data, num_output=10, kernel_size=[3, 3, 3], stride=[1, 1, 1], + pad=[0, 1, 2]) + n.pool = L.Pooling( + n.conv, pool=P.Pooling.MAX, kernel_size=2, stride=2, pad=0) + n.deconv = L.Deconvolution( + n.pool, num_output=10, kernel_size=4, stride=2, pad=0) + ax, a, b = coord_map_from_to(n.deconv, n.data) + self.assertEquals(ax, 1) + self.assertTrue(len(a) == len(b)) + self.assertTrue(np.all(a == 1)) + self.assertEquals(b[0] - 1, b[1]) + self.assertEquals(b[1] - 1, b[2]) + + def test_crop_of_crop(self): + """ + Map coordinates through Crop layer: + crop an already-cropped output to the input and check change in offset. + """ + n = coord_net_spec() + offset = random.randint(0, 10) + ax, a, b = coord_map_from_to(n.deconv, n.data) + n.crop = L.Crop(n.deconv, n.data, axis=2, offset=offset) + ax_crop, a_crop, b_crop = coord_map_from_to(n.crop, n.data) + self.assertEquals(ax, ax_crop) + self.assertEquals(a, a_crop) + self.assertEquals(b + offset, b_crop) + + def test_crop_helper(self): + """ + Define Crop layer by crop(). + """ + n = coord_net_spec() + crop(n.deconv, n.data) + + def test_catch_unconnected(self): + """ + Catch mapping spatially unconnected tops. + """ + n = coord_net_spec() + n.ip = L.InnerProduct(n.deconv, num_output=10) + with self.assertRaises(RuntimeError): + coord_map_from_to(n.ip, n.data) + + def test_catch_scale_mismatch(self): + """ + Catch incompatible scales, such as when the top to be cropped + is mapped to a differently strided reference top. + """ + n = coord_net_spec(pool=3, dstride=2) # pool 3x but deconv 2x + with self.assertRaises(AssertionError): + crop(n.deconv, n.data) + + def test_catch_negative_crop(self): + """ + Catch impossible offsets, such as when the top to be cropped + is mapped to a larger reference top. + """ + n = coord_net_spec(dpad=10) # make output smaller than input + with self.assertRaises(AssertionError): + crop(n.deconv, n.data) diff --git a/python/caffe/test/test_io.py b/python/caffe/test/test_io.py new file mode 100644 index 0000000..4a16b5b --- /dev/null +++ b/python/caffe/test/test_io.py @@ -0,0 +1,56 @@ +import numpy as np +import unittest + +import caffe + +class TestBlobProtoToArray(unittest.TestCase): + + def test_old_format(self): + data = np.zeros((10,10)) + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + shape = (1,1,10,10) + blob.num, blob.channels, blob.height, blob.width = shape + + arr = caffe.io.blobproto_to_array(blob) + self.assertEqual(arr.shape, shape) + + def test_new_format(self): + data = np.zeros((10,10)) + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + blob.shape.dim.extend(list(data.shape)) + + arr = caffe.io.blobproto_to_array(blob) + self.assertEqual(arr.shape, data.shape) + + def test_no_shape(self): + data = np.zeros((10,10)) + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + + with self.assertRaises(ValueError): + caffe.io.blobproto_to_array(blob) + + def test_scalar(self): + data = np.ones((1)) * 123 + blob = caffe.proto.caffe_pb2.BlobProto() + blob.data.extend(list(data.flatten())) + + arr = caffe.io.blobproto_to_array(blob) + self.assertEqual(arr, 123) + + +class TestArrayToDatum(unittest.TestCase): + + def test_label_none_size(self): + # Set label + d1 = caffe.io.array_to_datum( + np.ones((10,10,3)), label=1) + # Don't set label + d2 = caffe.io.array_to_datum( + np.ones((10,10,3))) + # Not setting the label should result in a smaller object + self.assertGreater( + len(d1.SerializeToString()), + len(d2.SerializeToString())) diff --git a/python/caffe/test/test_layer_type_list.py b/python/caffe/test/test_layer_type_list.py new file mode 100644 index 0000000..47f4cf6 --- /dev/null +++ b/python/caffe/test/test_layer_type_list.py @@ -0,0 +1,11 @@ +import unittest + +import caffe + +class TestLayerTypeList(unittest.TestCase): + + def test_standard_types(self): + #removing 'Data' from list + for type_name in ['Data', 'Convolution', 'InnerProduct']: + self.assertIn(type_name, caffe.layer_type_list(), + '%s not in layer_type_list()' % type_name) diff --git a/python/caffe/test/test_net.py b/python/caffe/test/test_net.py new file mode 100644 index 0000000..4cacfcd --- /dev/null +++ b/python/caffe/test/test_net.py @@ -0,0 +1,95 @@ +import unittest +import tempfile +import os +import numpy as np +import six + +import caffe + + +def simple_net_file(num_output): + """Make a simple net prototxt, based on test_net.cpp, returning the name + of the (temporary) file.""" + + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) + f.write("""name: 'testnet' force_backward: true + layer { type: 'DummyData' name: 'data' top: 'data' top: 'label' + dummy_data_param { num: 5 channels: 2 height: 3 width: 4 + num: 5 channels: 1 height: 1 width: 1 + data_filler { type: 'gaussian' std: 1 } + data_filler { type: 'constant' } } } + layer { type: 'Convolution' name: 'conv' bottom: 'data' top: 'conv' + convolution_param { num_output: 11 kernel_size: 2 pad: 3 + weight_filler { type: 'gaussian' std: 1 } + bias_filler { type: 'constant' value: 2 } } + param { decay_mult: 1 } param { decay_mult: 0 } + } + layer { type: 'InnerProduct' name: 'ip' bottom: 'conv' top: 'ip' + inner_product_param { num_output: """ + str(num_output) + """ + weight_filler { type: 'gaussian' std: 2.5 } + bias_filler { type: 'constant' value: -3 } } } + layer { type: 'SoftmaxWithLoss' name: 'loss' bottom: 'ip' bottom: 'label' + top: 'loss' }""") + f.close() + return f.name + + +class TestNet(unittest.TestCase): + def setUp(self): + self.num_output = 13 + net_file = simple_net_file(self.num_output) + self.net = caffe.Net(net_file, caffe.TRAIN) + # fill in valid labels + self.net.blobs['label'].data[...] = \ + np.random.randint(self.num_output, + size=self.net.blobs['label'].data.shape) + os.remove(net_file) + + def test_memory(self): + """Check that holding onto blob data beyond the life of a Net is OK""" + + params = sum(map(list, six.itervalues(self.net.params)), []) + blobs = self.net.blobs.values() + del self.net + + # now sum everything (forcing all memory to be read) + total = 0 + for p in params: + total += p.data.sum() + p.diff.sum() + for bl in blobs: + total += bl.data.sum() + bl.diff.sum() + + def test_forward_backward(self): + self.net.forward() + self.net.backward() + + def test_inputs_outputs(self): + self.assertEqual(self.net.inputs, []) + self.assertEqual(self.net.outputs, ['loss']) + + def test_save_and_read(self): + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) + f.close() + self.net.save(f.name) + net_file = simple_net_file(self.num_output) + net2 = caffe.Net(net_file, f.name, caffe.TRAIN) + os.remove(net_file) + os.remove(f.name) + for name in self.net.params: + for i in range(len(self.net.params[name])): + self.assertEqual(abs(self.net.params[name][i].data + - net2.params[name][i].data).sum(), 0) + + def test_save_hdf5(self): + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) + f.close() + self.net.save_hdf5(f.name) + net_file = simple_net_file(self.num_output) + net2 = caffe.Net(net_file, caffe.TRAIN) + net2.load_hdf5(f.name) + os.remove(net_file) + os.remove(f.name) + for name in self.net.params: + for i in range(len(self.net.params[name])): + self.assertEqual(abs(self.net.params[name][i].data + - net2.params[name][i].data).sum(), 0) diff --git a/python/caffe/test/test_net_spec.py b/python/caffe/test/test_net_spec.py new file mode 100644 index 0000000..fee3c0a --- /dev/null +++ b/python/caffe/test/test_net_spec.py @@ -0,0 +1,81 @@ +import unittest +import tempfile +import caffe +from caffe import layers as L +from caffe import params as P + +def lenet(batch_size): + n = caffe.NetSpec() + n.data, n.label = L.DummyData(shape=[dict(dim=[batch_size, 1, 28, 28]), + dict(dim=[batch_size, 1, 1, 1])], + transform_param=dict(scale=1./255), ntop=2) + n.conv1 = L.Convolution(n.data, kernel_size=5, num_output=20, + weight_filler=dict(type='xavier')) + n.pool1 = L.Pooling(n.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX) + n.conv2 = L.Convolution(n.pool1, kernel_size=5, num_output=50, + weight_filler=dict(type='xavier')) + n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX) + n.ip1 = L.InnerProduct(n.pool2, num_output=500, + weight_filler=dict(type='xavier')) + n.relu1 = L.ReLU(n.ip1, in_place=True) + n.ip2 = L.InnerProduct(n.relu1, num_output=10, + weight_filler=dict(type='xavier')) + n.loss = L.SoftmaxWithLoss(n.ip2, n.label) + return n.to_proto() + +def anon_lenet(batch_size): + data, label = L.DummyData(shape=[dict(dim=[batch_size, 1, 28, 28]), + dict(dim=[batch_size, 1, 1, 1])], + transform_param=dict(scale=1./255), ntop=2) + conv1 = L.Convolution(data, kernel_size=5, num_output=20, + weight_filler=dict(type='xavier')) + pool1 = L.Pooling(conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX) + conv2 = L.Convolution(pool1, kernel_size=5, num_output=50, + weight_filler=dict(type='xavier')) + pool2 = L.Pooling(conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX) + ip1 = L.InnerProduct(pool2, num_output=500, + weight_filler=dict(type='xavier')) + relu1 = L.ReLU(ip1, in_place=True) + ip2 = L.InnerProduct(relu1, num_output=10, + weight_filler=dict(type='xavier')) + loss = L.SoftmaxWithLoss(ip2, label) + return loss.to_proto() + +def silent_net(): + n = caffe.NetSpec() + n.data, n.data2 = L.DummyData(shape=dict(dim=3), ntop=2) + n.silence_data = L.Silence(n.data, ntop=0) + n.silence_data2 = L.Silence(n.data2, ntop=0) + return n.to_proto() + +class TestNetSpec(unittest.TestCase): + def load_net(self, net_proto): + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) + f.write(str(net_proto)) + f.close() + return caffe.Net(f.name, caffe.TEST) + + def test_lenet(self): + """Construct and build the Caffe version of LeNet.""" + + net_proto = lenet(50) + # check that relu is in-place + self.assertEqual(net_proto.layer[6].bottom, + net_proto.layer[6].top) + net = self.load_net(net_proto) + # check that all layers are present + self.assertEqual(len(net.layers), 9) + + # now the check the version with automatically-generated layer names + net_proto = anon_lenet(50) + self.assertEqual(net_proto.layer[6].bottom, + net_proto.layer[6].top) + net = self.load_net(net_proto) + self.assertEqual(len(net.layers), 9) + + def test_zero_tops(self): + """Test net construction for top-less layers.""" + + net_proto = silent_net() + net = self.load_net(net_proto) + self.assertEqual(len(net.forward()), 0) diff --git a/python/caffe/test/test_python_layer.py b/python/caffe/test/test_python_layer.py new file mode 100644 index 0000000..899514e --- /dev/null +++ b/python/caffe/test/test_python_layer.py @@ -0,0 +1,168 @@ +import unittest +import tempfile +import os +import six + +import caffe + + +class SimpleLayer(caffe.Layer): + """A layer that just multiplies by ten""" + + def setup(self, bottom, top): + pass + + def reshape(self, bottom, top): + top[0].reshape(*bottom[0].data.shape) + + def forward(self, bottom, top): + top[0].data[...] = 10 * bottom[0].data + + def backward(self, top, propagate_down, bottom): + bottom[0].diff[...] = 10 * top[0].diff + + +class ExceptionLayer(caffe.Layer): + """A layer for checking exceptions from Python""" + + def setup(self, bottom, top): + raise RuntimeError + +class ParameterLayer(caffe.Layer): + """A layer that just multiplies by ten""" + + def setup(self, bottom, top): + self.blobs.add_blob(1) + self.blobs[0].data[0] = 0 + + def reshape(self, bottom, top): + top[0].reshape(*bottom[0].data.shape) + + def forward(self, bottom, top): + pass + + def backward(self, top, propagate_down, bottom): + self.blobs[0].diff[0] = 1 + +class PhaseLayer(caffe.Layer): + """A layer for checking attribute `phase`""" + + def setup(self, bottom, top): + pass + + def reshape(self, bootom, top): + top[0].reshape() + + def forward(self, bottom, top): + top[0].data[()] = self.phase + +def python_net_file(): + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } + layer { type: 'Python' name: 'one' bottom: 'data' top: 'one' + python_param { module: 'test_python_layer' layer: 'SimpleLayer' } } + layer { type: 'Python' name: 'two' bottom: 'one' top: 'two' + python_param { module: 'test_python_layer' layer: 'SimpleLayer' } } + layer { type: 'Python' name: 'three' bottom: 'two' top: 'three' + python_param { module: 'test_python_layer' layer: 'SimpleLayer' } }""") + return f.name + + +def exception_net_file(): + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } + layer { type: 'Python' name: 'layer' bottom: 'data' top: 'top' + python_param { module: 'test_python_layer' layer: 'ExceptionLayer' } } + """) + return f.name + + +def parameter_net_file(): + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } + layer { type: 'Python' name: 'layer' bottom: 'data' top: 'top' + python_param { module: 'test_python_layer' layer: 'ParameterLayer' } } + """) + return f.name + +def phase_net_file(): + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + layer { type: 'Python' name: 'layer' top: 'phase' + python_param { module: 'test_python_layer' layer: 'PhaseLayer' } } + """) + return f.name + + +@unittest.skipIf('Python' not in caffe.layer_type_list(), + 'Caffe built without Python layer support') +class TestPythonLayer(unittest.TestCase): + def setUp(self): + net_file = python_net_file() + self.net = caffe.Net(net_file, caffe.TRAIN) + os.remove(net_file) + + def test_forward(self): + x = 8 + self.net.blobs['data'].data[...] = x + self.net.forward() + for y in self.net.blobs['three'].data.flat: + self.assertEqual(y, 10**3 * x) + + def test_backward(self): + x = 7 + self.net.blobs['three'].diff[...] = x + self.net.backward() + for y in self.net.blobs['data'].diff.flat: + self.assertEqual(y, 10**3 * x) + + def test_reshape(self): + s = 4 + self.net.blobs['data'].reshape(s, s, s, s) + self.net.forward() + for blob in six.itervalues(self.net.blobs): + for d in blob.data.shape: + self.assertEqual(s, d) + + def test_exception(self): + net_file = exception_net_file() + self.assertRaises(RuntimeError, caffe.Net, net_file, caffe.TEST) + os.remove(net_file) + + def test_parameter(self): + net_file = parameter_net_file() + net = caffe.Net(net_file, caffe.TRAIN) + # Test forward and backward + net.forward() + net.backward() + layer = net.layers[list(net._layer_names).index('layer')] + self.assertEqual(layer.blobs[0].data[0], 0) + self.assertEqual(layer.blobs[0].diff[0], 1) + layer.blobs[0].data[0] += layer.blobs[0].diff[0] + self.assertEqual(layer.blobs[0].data[0], 1) + + # Test saving and loading + h, caffemodel_file = tempfile.mkstemp() + net.save(caffemodel_file) + layer.blobs[0].data[0] = -1 + self.assertEqual(layer.blobs[0].data[0], -1) + net.copy_from(caffemodel_file) + self.assertEqual(layer.blobs[0].data[0], 1) + os.remove(caffemodel_file) + + # Test weight sharing + net2 = caffe.Net(net_file, caffe.TRAIN) + net2.share_with(net) + layer = net.layers[list(net2._layer_names).index('layer')] + self.assertEqual(layer.blobs[0].data[0], 1) + + os.remove(net_file) + + def test_phase(self): + net_file = phase_net_file() + for phase in caffe.TRAIN, caffe.TEST: + net = caffe.Net(net_file, phase) + self.assertEqual(net.forward()['phase'], phase) diff --git a/python/caffe/test/test_python_layer_with_param_str.py b/python/caffe/test/test_python_layer_with_param_str.py new file mode 100644 index 0000000..c36048a --- /dev/null +++ b/python/caffe/test/test_python_layer_with_param_str.py @@ -0,0 +1,61 @@ +import unittest +import tempfile +import os +import six + +import caffe + + +class SimpleParamLayer(caffe.Layer): + """A layer that just multiplies by the numeric value of its param string""" + + def setup(self, bottom, top): + try: + self.value = float(self.param_str) + except ValueError: + raise ValueError("Parameter string must be a legible float") + + def reshape(self, bottom, top): + top[0].reshape(*bottom[0].data.shape) + + def forward(self, bottom, top): + top[0].data[...] = self.value * bottom[0].data + + def backward(self, top, propagate_down, bottom): + bottom[0].diff[...] = self.value * top[0].diff + + +def python_param_net_file(): + with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f: + f.write("""name: 'pythonnet' force_backward: true + input: 'data' input_shape { dim: 10 dim: 9 dim: 8 } + layer { type: 'Python' name: 'mul10' bottom: 'data' top: 'mul10' + python_param { module: 'test_python_layer_with_param_str' + layer: 'SimpleParamLayer' param_str: '10' } } + layer { type: 'Python' name: 'mul2' bottom: 'mul10' top: 'mul2' + python_param { module: 'test_python_layer_with_param_str' + layer: 'SimpleParamLayer' param_str: '2' } }""") + return f.name + + +@unittest.skipIf('Python' not in caffe.layer_type_list(), + 'Caffe built without Python layer support') +class TestLayerWithParam(unittest.TestCase): + def setUp(self): + net_file = python_param_net_file() + self.net = caffe.Net(net_file, caffe.TRAIN) + os.remove(net_file) + + def test_forward(self): + x = 8 + self.net.blobs['data'].data[...] = x + self.net.forward() + for y in self.net.blobs['mul2'].data.flat: + self.assertEqual(y, 2 * 10 * x) + + def test_backward(self): + x = 7 + self.net.blobs['mul2'].diff[...] = x + self.net.backward() + for y in self.net.blobs['data'].diff.flat: + self.assertEqual(y, 2 * 10 * x) diff --git a/python/caffe/test/test_solver.py b/python/caffe/test/test_solver.py new file mode 100644 index 0000000..f618fde --- /dev/null +++ b/python/caffe/test/test_solver.py @@ -0,0 +1,62 @@ +import unittest +import tempfile +import os +import numpy as np +import six + +import caffe +from test_net import simple_net_file + + +class TestSolver(unittest.TestCase): + def setUp(self): + self.num_output = 13 + net_f = simple_net_file(self.num_output) + f = tempfile.NamedTemporaryFile(mode='w+', delete=False) + f.write("""net: '""" + net_f + """' + test_iter: 10 test_interval: 10 base_lr: 0.01 momentum: 0.9 + weight_decay: 0.0005 lr_policy: 'inv' gamma: 0.0001 power: 0.75 + display: 100 max_iter: 100 snapshot_after_train: false + snapshot_prefix: "model" """) + f.close() + self.solver = caffe.SGDSolver(f.name) + # also make sure get_solver runs + caffe.get_solver(f.name) + caffe.set_mode_cpu() + # fill in valid labels + self.solver.net.blobs['label'].data[...] = \ + np.random.randint(self.num_output, + size=self.solver.net.blobs['label'].data.shape) + self.solver.test_nets[0].blobs['label'].data[...] = \ + np.random.randint(self.num_output, + size=self.solver.test_nets[0].blobs['label'].data.shape) + os.remove(f.name) + os.remove(net_f) + + def test_solve(self): + self.assertEqual(self.solver.iter, 0) + self.solver.solve() + self.assertEqual(self.solver.iter, 100) + + def test_net_memory(self): + """Check that nets survive after the solver is destroyed.""" + + nets = [self.solver.net] + list(self.solver.test_nets) + self.assertEqual(len(nets), 2) + del self.solver + + total = 0 + for net in nets: + for ps in six.itervalues(net.params): + for p in ps: + total += p.data.sum() + p.diff.sum() + for bl in six.itervalues(net.blobs): + total += bl.data.sum() + bl.diff.sum() + + def test_snapshot(self): + self.solver.snapshot() + # Check that these files exist and then remove them + files = ['model_iter_0.caffemodel', 'model_iter_0.solverstate'] + for fn in files: + assert os.path.isfile(fn) + os.remove(fn) diff --git a/python/classify.py b/python/classify.py new file mode 100644 index 0000000..4544c51 --- /dev/null +++ b/python/classify.py @@ -0,0 +1,138 @@ +#!/usr/bin/env python +""" +classify.py is an out-of-the-box image classifer callable from the command line. + +By default it configures and runs the Caffe reference ImageNet model. +""" +import numpy as np +import os +import sys +import argparse +import glob +import time + +import caffe + + +def main(argv): + pycaffe_dir = os.path.dirname(__file__) + + parser = argparse.ArgumentParser() + # Required arguments: input and output files. + parser.add_argument( + "input_file", + help="Input image, directory, or npy." + ) + parser.add_argument( + "output_file", + help="Output npy filename." + ) + # Optional arguments. + parser.add_argument( + "--model_def", + default=os.path.join(pycaffe_dir, + "../models/bvlc_reference_caffenet/deploy.prototxt"), + help="Model definition file." + ) + parser.add_argument( + "--pretrained_model", + default=os.path.join(pycaffe_dir, + "../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel"), + help="Trained model weights file." + ) + parser.add_argument( + "--gpu", + action='store_true', + help="Switch for gpu computation." + ) + parser.add_argument( + "--center_only", + action='store_true', + help="Switch for prediction from center crop alone instead of " + + "averaging predictions across crops (default)." + ) + parser.add_argument( + "--images_dim", + default='256,256', + help="Canonical 'height,width' dimensions of input images." + ) + parser.add_argument( + "--mean_file", + default=os.path.join(pycaffe_dir, + 'caffe/imagenet/ilsvrc_2012_mean.npy'), + help="Data set image mean of [Channels x Height x Width] dimensions " + + "(numpy array). Set to '' for no mean subtraction." + ) + parser.add_argument( + "--input_scale", + type=float, + help="Multiply input features by this scale to finish preprocessing." + ) + parser.add_argument( + "--raw_scale", + type=float, + default=255.0, + help="Multiply raw input by this scale before preprocessing." + ) + parser.add_argument( + "--channel_swap", + default='2,1,0', + help="Order to permute input channels. The default converts " + + "RGB -> BGR since BGR is the Caffe default by way of OpenCV." + ) + parser.add_argument( + "--ext", + default='jpg', + help="Image file extension to take as input when a directory " + + "is given as the input file." + ) + args = parser.parse_args() + + image_dims = [int(s) for s in args.images_dim.split(',')] + + mean, channel_swap = None, None + if args.mean_file: + mean = np.load(args.mean_file) + if args.channel_swap: + channel_swap = [int(s) for s in args.channel_swap.split(',')] + + if args.gpu: + caffe.set_mode_gpu() + print("GPU mode") + else: + caffe.set_mode_cpu() + print("CPU mode") + + # Make classifier. + classifier = caffe.Classifier(args.model_def, args.pretrained_model, + image_dims=image_dims, mean=mean, + input_scale=args.input_scale, raw_scale=args.raw_scale, + channel_swap=channel_swap) + + # Load numpy array (.npy), directory glob (*.jpg), or image file. + args.input_file = os.path.expanduser(args.input_file) + if args.input_file.endswith('npy'): + print("Loading file: %s" % args.input_file) + inputs = np.load(args.input_file) + elif os.path.isdir(args.input_file): + print("Loading folder: %s" % args.input_file) + inputs =[caffe.io.load_image(im_f) + for im_f in glob.glob(args.input_file + '/*.' + args.ext)] + else: + print("Loading file: %s" % args.input_file) + inputs = [caffe.io.load_image(args.input_file)] + + print("Classifying %d inputs." % len(inputs)) + + # Classify. + start = time.time() + predictions = classifier.predict(inputs, not args.center_only) + print("Done in %.2f s." % (time.time() - start)) + + # Save + print("Saving results into %s" % args.output_file) + np.save(args.output_file, predictions) + + +if __name__ == '__main__': + main(sys.argv) diff --git a/python/detect.py b/python/detect.py new file mode 100644 index 0000000..1aba964 --- /dev/null +++ b/python/detect.py @@ -0,0 +1,173 @@ +#!/usr/bin/env python +""" +detector.py is an out-of-the-box windowed detector +callable from the command line. + +By default it configures and runs the Caffe reference ImageNet model. +Note that this model was trained for image classification and not detection, +and finetuning for detection can be expected to improve results. + +The selective_search_ijcv_with_python code required for the selective search +proposal mode is available at + https://github.com/sergeyk/selective_search_ijcv_with_python + +TODO: +- batch up image filenames as well: don't want to load all of them into memory +- come up with a batching scheme that preserved order / keeps a unique ID +""" +import numpy as np +import pandas as pd +import os +import argparse +import time + +import caffe + +CROP_MODES = ['list', 'selective_search'] +COORD_COLS = ['ymin', 'xmin', 'ymax', 'xmax'] + + +def main(argv): + pycaffe_dir = os.path.dirname(__file__) + + parser = argparse.ArgumentParser() + # Required arguments: input and output. + parser.add_argument( + "input_file", + help="Input txt/csv filename. If .txt, must be list of filenames.\ + If .csv, must be comma-separated file with header\ + 'filename, xmin, ymin, xmax, ymax'" + ) + parser.add_argument( + "output_file", + help="Output h5/csv filename. Format depends on extension." + ) + # Optional arguments. + parser.add_argument( + "--model_def", + default=os.path.join(pycaffe_dir, + "../models/bvlc_reference_caffenet/deploy.prototxt"), + help="Model definition file." + ) + parser.add_argument( + "--pretrained_model", + default=os.path.join(pycaffe_dir, + "../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel"), + help="Trained model weights file." + ) + parser.add_argument( + "--crop_mode", + default="selective_search", + choices=CROP_MODES, + help="How to generate windows for detection." + ) + parser.add_argument( + "--gpu", + action='store_true', + help="Switch for gpu computation." + ) + parser.add_argument( + "--mean_file", + default=os.path.join(pycaffe_dir, + 'caffe/imagenet/ilsvrc_2012_mean.npy'), + help="Data set image mean of H x W x K dimensions (numpy array). " + + "Set to '' for no mean subtraction." + ) + parser.add_argument( + "--input_scale", + type=float, + help="Multiply input features by this scale to finish preprocessing." + ) + parser.add_argument( + "--raw_scale", + type=float, + default=255.0, + help="Multiply raw input by this scale before preprocessing." + ) + parser.add_argument( + "--channel_swap", + default='2,1,0', + help="Order to permute input channels. The default converts " + + "RGB -> BGR since BGR is the Caffe default by way of OpenCV." + + ) + parser.add_argument( + "--context_pad", + type=int, + default='16', + help="Amount of surrounding context to collect in input window." + ) + args = parser.parse_args() + + mean, channel_swap = None, None + if args.mean_file: + mean = np.load(args.mean_file) + if mean.shape[1:] != (1, 1): + mean = mean.mean(1).mean(1) + if args.channel_swap: + channel_swap = [int(s) for s in args.channel_swap.split(',')] + + if args.gpu: + caffe.set_mode_gpu() + print("GPU mode") + else: + caffe.set_mode_cpu() + print("CPU mode") + + # Make detector. + detector = caffe.Detector(args.model_def, args.pretrained_model, mean=mean, + input_scale=args.input_scale, raw_scale=args.raw_scale, + channel_swap=channel_swap, + context_pad=args.context_pad) + + # Load input. + t = time.time() + print("Loading input...") + if args.input_file.lower().endswith('txt'): + with open(args.input_file) as f: + inputs = [_.strip() for _ in f.readlines()] + elif args.input_file.lower().endswith('csv'): + inputs = pd.read_csv(args.input_file, sep=',', dtype={'filename': str}) + inputs.set_index('filename', inplace=True) + else: + raise Exception("Unknown input file type: not in txt or csv.") + + # Detect. + if args.crop_mode == 'list': + # Unpack sequence of (image filename, windows). + images_windows = [ + (ix, inputs.iloc[np.where(inputs.index == ix)][COORD_COLS].values) + for ix in inputs.index.unique() + ] + detections = detector.detect_windows(images_windows) + else: + detections = detector.detect_selective_search(inputs) + print("Processed {} windows in {:.3f} s.".format(len(detections), + time.time() - t)) + + # Collect into dataframe with labeled fields. + df = pd.DataFrame(detections) + df.set_index('filename', inplace=True) + df[COORD_COLS] = pd.DataFrame( + data=np.vstack(df['window']), index=df.index, columns=COORD_COLS) + del(df['window']) + + # Save results. + t = time.time() + if args.output_file.lower().endswith('csv'): + # csv + # Enumerate the class probabilities. + class_cols = ['class{}'.format(x) for x in range(NUM_OUTPUT)] + df[class_cols] = pd.DataFrame( + data=np.vstack(df['feat']), index=df.index, columns=class_cols) + df.to_csv(args.output_file, cols=COORD_COLS + class_cols) + else: + # h5 + df.to_hdf(args.output_file, 'df', mode='w') + print("Saved to {} in {:.3f} s.".format(args.output_file, + time.time() - t)) + + +if __name__ == "__main__": + import sys + main(sys.argv) diff --git a/python/draw_net.py b/python/draw_net.py new file mode 100644 index 0000000..ec76a74 --- /dev/null +++ b/python/draw_net.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python +""" +Draw a graph of the net architecture. +""" +from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter +from google.protobuf import text_format + +import caffe +import caffe.draw +from caffe.proto import caffe_pb2 + + +def parse_args(): + """Parse input arguments + """ + + parser = ArgumentParser(description=__doc__, + formatter_class=ArgumentDefaultsHelpFormatter) + + parser.add_argument('input_net_proto_file', + help='Input network prototxt file') + parser.add_argument('output_image_file', + help='Output image file') + parser.add_argument('--rankdir', + help=('One of TB (top-bottom, i.e., vertical), ' + 'RL (right-left, i.e., horizontal), or another ' + 'valid dot option; see ' + 'http://www.graphviz.org/doc/info/' + 'attrs.html#k:rankdir'), + default='LR') + + args = parser.parse_args() + return args + + +def main(): + args = parse_args() + net = caffe_pb2.NetParameter() + text_format.Merge(open(args.input_net_proto_file).read(), net) + print('Drawing net to %s' % args.output_image_file) + caffe.draw.draw_net_to_file(net, args.output_image_file, args.rankdir) + + +if __name__ == '__main__': + main() diff --git a/python/layers/python_layers.py b/python/layers/python_layers.py new file mode 100644 index 0000000..270b8ed --- /dev/null +++ b/python/layers/python_layers.py @@ -0,0 +1,49 @@ +import caffe +import numpy as np + +class Meshgrid(caffe.Layer): + + def setup(self, bottom, top): + params = eval(self.param_str) + self.width = params['width'] + self.height = params['height'] + self.batch = params['batch'] + + def reshape(self, bottom, top): + assert len(bottom) == 0, "No bottom accepted" + assert len(top) == 1, "Only one top accepted" + top[0].reshape(self.batch, 2, self.height, self.width) + # top[1].reshape(self.batch, 1, self.height, self.width) + + def forward(self, bottom, top): + gx, gy = np.meshgrid(range(self.width), range(self.height)) + gxy = np.concatenate((gx[None,:,:], gy[None,:,:]), axis=0) + top[0].data[...] = gxy[None, :, :, :] + # top[1].data[...] = gy[None,None,:,:] + + def backward(self, top, propagate_down, bottom): + pass + +class MeanVals(caffe.Layer): + + def setup(self, bottom, top): + params = eval(self.param_str) + self.width = params['width'] + self.height = params['height'] + self.batch = params['batch'] + + def reshape(self, bottom, top): + assert len(bottom) == 0, "No bottom accepted" + assert len(top) == 1, "Only one top accepted" + top[0].reshape(self.batch, 3, self.height, self.width) + + def forward(self, bottom, top): + m1 = 104 * np.ones((self.height, self.width)) + m2 = 117 * np.ones((self.height, self.width)) + m3 = 123 * np.ones((self.height, self.width)) + mall = np.concatenate((m1[None,:,:], m2[None,:,:], m3[None,:,:]), axis=0) + top[0].data[...] = mall[None, :, :, :] + # top[1].data[...] = gy[None,None,:,:] + + def backward(self, top, propagate_down, bottom): + pass diff --git a/python/layers/python_layers.pyc b/python/layers/python_layers.pyc new file mode 100644 index 0000000..8859442 Binary files /dev/null and b/python/layers/python_layers.pyc differ diff --git a/python/requirements.txt b/python/requirements.txt new file mode 100644 index 0000000..e7d89e6 --- /dev/null +++ b/python/requirements.txt @@ -0,0 +1,17 @@ +Cython>=0.19.2 +numpy>=1.7.1 +scipy>=0.13.2 +scikit-image>=0.9.3 +matplotlib>=1.3.1 +ipython>=3.0.0 +h5py>=2.2.0 +leveldb>=0.191 +networkx>=1.8.1 +nose>=1.3.0 +pandas>=0.12.0 +python-dateutil>=1.4,<2 +protobuf>=2.5.0 +python-gflags>=2.0 +pyyaml>=3.10 +Pillow>=2.3.0 +six>=1.1.0 \ No newline at end of file