model.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: model.proto

#ifndef PROTOBUF_model_2eproto__INCLUDED
#define PROTOBUF_model_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace singa {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_model_2eproto();
void protobuf_AssignDesc_model_2eproto();
void protobuf_ShutdownFile_model_2eproto();

class ModelProto;
class NetProto;
class ParamProto;
class BlobProtos;
class LayerProto;
class RGBImage;
class SplitProto;
class TanhProto;
class SoftmaxLossProto;
class ConvolutionProto;
class ConcateProto;
class DataProto;
class MnistProto;
class DropoutProto;
class InnerProductProto;
class LRNProto;
class PoolingProto;
class SliceProto;
class ReLUProto;
class Record;
class Datum;
class SingleLabelImageRecord;
class UpdaterProto;
class BlobProto;

enum ModelProto_GradCalcAlg {
  ModelProto_GradCalcAlg_kBackPropagation = 1,
  ModelProto_GradCalcAlg_kContrastiveDivergence = 2
};
bool ModelProto_GradCalcAlg_IsValid(int value);
const ModelProto_GradCalcAlg ModelProto_GradCalcAlg_GradCalcAlg_MIN = ModelProto_GradCalcAlg_kBackPropagation;
const ModelProto_GradCalcAlg ModelProto_GradCalcAlg_GradCalcAlg_MAX = ModelProto_GradCalcAlg_kContrastiveDivergence;
const int ModelProto_GradCalcAlg_GradCalcAlg_ARRAYSIZE = ModelProto_GradCalcAlg_GradCalcAlg_MAX + 1;

const ::google::protobuf::EnumDescriptor* ModelProto_GradCalcAlg_descriptor();
inline const ::std::string& ModelProto_GradCalcAlg_Name(ModelProto_GradCalcAlg value) {
  return ::google::protobuf::internal::NameOfEnum(
    ModelProto_GradCalcAlg_descriptor(), value);
}
inline bool ModelProto_GradCalcAlg_Parse(
    const ::std::string& name, ModelProto_GradCalcAlg* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ModelProto_GradCalcAlg>(
    ModelProto_GradCalcAlg_descriptor(), name, value);
}
enum ParamProto_InitMethod {
  ParamProto_InitMethod_kConstant = 0,
  ParamProto_InitMethod_kGaussian = 1,
  ParamProto_InitMethod_kUniform = 2,
  ParamProto_InitMethod_kPretrained = 3,
  ParamProto_InitMethod_kGaussainSqrtFanIn = 4,
  ParamProto_InitMethod_kUniformSqrtFanIn = 5,
  ParamProto_InitMethod_kUniformSqrtFanInOut = 6
};
bool ParamProto_InitMethod_IsValid(int value);
const ParamProto_InitMethod ParamProto_InitMethod_InitMethod_MIN = ParamProto_InitMethod_kConstant;
const ParamProto_InitMethod ParamProto_InitMethod_InitMethod_MAX = ParamProto_InitMethod_kUniformSqrtFanInOut;
const int ParamProto_InitMethod_InitMethod_ARRAYSIZE = ParamProto_InitMethod_InitMethod_MAX + 1;

const ::google::protobuf::EnumDescriptor* ParamProto_InitMethod_descriptor();
inline const ::std::string& ParamProto_InitMethod_Name(ParamProto_InitMethod value) {
  return ::google::protobuf::internal::NameOfEnum(
    ParamProto_InitMethod_descriptor(), value);
}
inline bool ParamProto_InitMethod_Parse(
    const ::std::string& name, ParamProto_InitMethod* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ParamProto_InitMethod>(
    ParamProto_InitMethod_descriptor(), name, value);
}
enum LRNProto_NormRegion {
  LRNProto_NormRegion_ACROSS_CHANNELS = 0,
  LRNProto_NormRegion_WITHIN_CHANNEL = 1
};
bool LRNProto_NormRegion_IsValid(int value);
const LRNProto_NormRegion LRNProto_NormRegion_NormRegion_MIN = LRNProto_NormRegion_ACROSS_CHANNELS;
const LRNProto_NormRegion LRNProto_NormRegion_NormRegion_MAX = LRNProto_NormRegion_WITHIN_CHANNEL;
const int LRNProto_NormRegion_NormRegion_ARRAYSIZE = LRNProto_NormRegion_NormRegion_MAX + 1;

const ::google::protobuf::EnumDescriptor* LRNProto_NormRegion_descriptor();
inline const ::std::string& LRNProto_NormRegion_Name(LRNProto_NormRegion value) {
  return ::google::protobuf::internal::NameOfEnum(
    LRNProto_NormRegion_descriptor(), value);
}
inline bool LRNProto_NormRegion_Parse(
    const ::std::string& name, LRNProto_NormRegion* value) {
  return ::google::protobuf::internal::ParseNamedEnum<LRNProto_NormRegion>(
    LRNProto_NormRegion_descriptor(), name, value);
}
enum PoolingProto_PoolMethod {
  PoolingProto_PoolMethod_MAX = 0,
  PoolingProto_PoolMethod_AVE = 1
};
bool PoolingProto_PoolMethod_IsValid(int value);
const PoolingProto_PoolMethod PoolingProto_PoolMethod_PoolMethod_MIN = PoolingProto_PoolMethod_MAX;
const PoolingProto_PoolMethod PoolingProto_PoolMethod_PoolMethod_MAX = PoolingProto_PoolMethod_AVE;
const int PoolingProto_PoolMethod_PoolMethod_ARRAYSIZE = PoolingProto_PoolMethod_PoolMethod_MAX + 1;

const ::google::protobuf::EnumDescriptor* PoolingProto_PoolMethod_descriptor();
inline const ::std::string& PoolingProto_PoolMethod_Name(PoolingProto_PoolMethod value) {
  return ::google::protobuf::internal::NameOfEnum(
    PoolingProto_PoolMethod_descriptor(), value);
}
inline bool PoolingProto_PoolMethod_Parse(
    const ::std::string& name, PoolingProto_PoolMethod* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PoolingProto_PoolMethod>(
    PoolingProto_PoolMethod_descriptor(), name, value);
}
enum Record_Type {
  Record_Type_kSingleLabelImage = 0
};
bool Record_Type_IsValid(int value);
const Record_Type Record_Type_Type_MIN = Record_Type_kSingleLabelImage;
const Record_Type Record_Type_Type_MAX = Record_Type_kSingleLabelImage;
const int Record_Type_Type_ARRAYSIZE = Record_Type_Type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Record_Type_descriptor();
inline const ::std::string& Record_Type_Name(Record_Type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Record_Type_descriptor(), value);
}
inline bool Record_Type_Parse(
    const ::std::string& name, Record_Type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Record_Type>(
    Record_Type_descriptor(), name, value);
}
enum UpdaterProto_ChangeProto {
  UpdaterProto_ChangeProto_kFixed = 0,
  UpdaterProto_ChangeProto_kInverse_t = 1,
  UpdaterProto_ChangeProto_kInverse = 2,
  UpdaterProto_ChangeProto_kExponential = 3,
  UpdaterProto_ChangeProto_kLinear = 4,
  UpdaterProto_ChangeProto_kStep = 5,
  UpdaterProto_ChangeProto_kFixedStep = 6
};
bool UpdaterProto_ChangeProto_IsValid(int value);
const UpdaterProto_ChangeProto UpdaterProto_ChangeProto_ChangeProto_MIN = UpdaterProto_ChangeProto_kFixed;
const UpdaterProto_ChangeProto UpdaterProto_ChangeProto_ChangeProto_MAX = UpdaterProto_ChangeProto_kFixedStep;
const int UpdaterProto_ChangeProto_ChangeProto_ARRAYSIZE = UpdaterProto_ChangeProto_ChangeProto_MAX + 1;

const ::google::protobuf::EnumDescriptor* UpdaterProto_ChangeProto_descriptor();
inline const ::std::string& UpdaterProto_ChangeProto_Name(UpdaterProto_ChangeProto value) {
  return ::google::protobuf::internal::NameOfEnum(
    UpdaterProto_ChangeProto_descriptor(), value);
}
inline bool UpdaterProto_ChangeProto_Parse(
    const ::std::string& name, UpdaterProto_ChangeProto* value) {
  return ::google::protobuf::internal::ParseNamedEnum<UpdaterProto_ChangeProto>(
    UpdaterProto_ChangeProto_descriptor(), name, value);
}
enum MsgType {
  kGet = 0,
  kPut = 1,
  kSync = 2,
  kUpdate = 3,
  kSyncRequest = 4,
  kSyncResponse = 5,
  kStop = 6,
  kData = 7,
  kRGet = 8,
  kRUpdate = 9,
  kConnect = 10,
  kMetric = 11
};
bool MsgType_IsValid(int value);
const MsgType MsgType_MIN = kGet;
const MsgType MsgType_MAX = kMetric;
const int MsgType_ARRAYSIZE = MsgType_MAX + 1;

const ::google::protobuf::EnumDescriptor* MsgType_descriptor();
inline const ::std::string& MsgType_Name(MsgType value) {
  return ::google::protobuf::internal::NameOfEnum(
    MsgType_descriptor(), value);
}
inline bool MsgType_Parse(
    const ::std::string& name, MsgType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<MsgType>(
    MsgType_descriptor(), name, value);
}
enum EntityType {
  kWorkerParam = 0,
  kWorkerLayer = 1,
  kServer = 2,
  kStub = 3,
  kRuntime = 4
};
bool EntityType_IsValid(int value);
const EntityType EntityType_MIN = kWorkerParam;
const EntityType EntityType_MAX = kRuntime;
const int EntityType_ARRAYSIZE = EntityType_MAX + 1;

const ::google::protobuf::EnumDescriptor* EntityType_descriptor();
inline const ::std::string& EntityType_Name(EntityType value) {
  return ::google::protobuf::internal::NameOfEnum(
    EntityType_descriptor(), value);
}
inline bool EntityType_Parse(
    const ::std::string& name, EntityType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<EntityType>(
    EntityType_descriptor(), name, value);
}
enum Phase {
  kTrain = 0,
  kValidation = 1,
  kTest = 2
};
bool Phase_IsValid(int value);
const Phase Phase_MIN = kTrain;
const Phase Phase_MAX = kTest;
const int Phase_ARRAYSIZE = Phase_MAX + 1;

const ::google::protobuf::EnumDescriptor* Phase_descriptor();
inline const ::std::string& Phase_Name(Phase value) {
  return ::google::protobuf::internal::NameOfEnum(
    Phase_descriptor(), value);
}
inline bool Phase_Parse(
    const ::std::string& name, Phase* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Phase>(
    Phase_descriptor(), name, value);
}
enum ShareOption {
  kValueOnly = 0,
  kWhole = 1
};
bool ShareOption_IsValid(int value);
const ShareOption ShareOption_MIN = kValueOnly;
const ShareOption ShareOption_MAX = kWhole;
const int ShareOption_ARRAYSIZE = ShareOption_MAX + 1;

const ::google::protobuf::EnumDescriptor* ShareOption_descriptor();
inline const ::std::string& ShareOption_Name(ShareOption value) {
  return ::google::protobuf::internal::NameOfEnum(
    ShareOption_descriptor(), value);
}
inline bool ShareOption_Parse(
    const ::std::string& name, ShareOption* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ShareOption>(
    ShareOption_descriptor(), name, value);
}
enum PartitionType {
  kDataPartition = 0,
  kLayerPartition = 1,
  kNone = 2
};
bool PartitionType_IsValid(int value);
const PartitionType PartitionType_MIN = kDataPartition;
const PartitionType PartitionType_MAX = kNone;
const int PartitionType_ARRAYSIZE = PartitionType_MAX + 1;

const ::google::protobuf::EnumDescriptor* PartitionType_descriptor();
inline const ::std::string& PartitionType_Name(PartitionType value) {
  return ::google::protobuf::internal::NameOfEnum(
    PartitionType_descriptor(), value);
}
inline bool PartitionType_Parse(
    const ::std::string& name, PartitionType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PartitionType>(
    PartitionType_descriptor(), name, value);
}
enum ConnectionType {
  kOneToOne = 0,
  kOneToAll = 1
};
bool ConnectionType_IsValid(int value);
const ConnectionType ConnectionType_MIN = kOneToOne;
const ConnectionType ConnectionType_MAX = kOneToAll;
const int ConnectionType_ARRAYSIZE = ConnectionType_MAX + 1;

const ::google::protobuf::EnumDescriptor* ConnectionType_descriptor();
inline const ::std::string& ConnectionType_Name(ConnectionType value) {
  return ::google::protobuf::internal::NameOfEnum(
    ConnectionType_descriptor(), value);
}
inline bool ConnectionType_Parse(
    const ::std::string& name, ConnectionType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ConnectionType>(
    ConnectionType_descriptor(), name, value);
}
// ===================================================================

class ModelProto : public ::google::protobuf::Message {
 public:
  ModelProto();
  virtual ~ModelProto();

  ModelProto(const ModelProto& from);

  inline ModelProto& operator=(const ModelProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ModelProto& default_instance();

  void Swap(ModelProto* other);

  // implements Message ----------------------------------------------

  ModelProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ModelProto& from);
  void MergeFrom(const ModelProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef ModelProto_GradCalcAlg GradCalcAlg;
  static const GradCalcAlg kBackPropagation = ModelProto_GradCalcAlg_kBackPropagation;
  static const GradCalcAlg kContrastiveDivergence = ModelProto_GradCalcAlg_kContrastiveDivergence;
  static inline bool GradCalcAlg_IsValid(int value) {
    return ModelProto_GradCalcAlg_IsValid(value);
  }
  static const GradCalcAlg GradCalcAlg_MIN =
    ModelProto_GradCalcAlg_GradCalcAlg_MIN;
  static const GradCalcAlg GradCalcAlg_MAX =
    ModelProto_GradCalcAlg_GradCalcAlg_MAX;
  static const int GradCalcAlg_ARRAYSIZE =
    ModelProto_GradCalcAlg_GradCalcAlg_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  GradCalcAlg_descriptor() {
    return ModelProto_GradCalcAlg_descriptor();
  }
  static inline const ::std::string& GradCalcAlg_Name(GradCalcAlg value) {
    return ModelProto_GradCalcAlg_Name(value);
  }
  static inline bool GradCalcAlg_Parse(const ::std::string& name,
      GradCalcAlg* value) {
    return ModelProto_GradCalcAlg_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // optional string train_folder = 2 [default = "train"];
  inline bool has_train_folder() const;
  inline void clear_train_folder();
  static const int kTrainFolderFieldNumber = 2;
  inline const ::std::string& train_folder() const;
  inline void set_train_folder(const ::std::string& value);
  inline void set_train_folder(const char* value);
  inline void set_train_folder(const char* value, size_t size);
  inline ::std::string* mutable_train_folder();
  inline ::std::string* release_train_folder();
  inline void set_allocated_train_folder(::std::string* train_folder);

  // optional string test_folder = 3 [default = "test"];
  inline bool has_test_folder() const;
  inline void clear_test_folder();
  static const int kTestFolderFieldNumber = 3;
  inline const ::std::string& test_folder() const;
  inline void set_test_folder(const ::std::string& value);
  inline void set_test_folder(const char* value);
  inline void set_test_folder(const char* value, size_t size);
  inline ::std::string* mutable_test_folder();
  inline ::std::string* release_test_folder();
  inline void set_allocated_test_folder(::std::string* test_folder);

  // optional string validation_folder = 4 [default = "validation"];
  inline bool has_validation_folder() const;
  inline void clear_validation_folder();
  static const int kValidationFolderFieldNumber = 4;
  inline const ::std::string& validation_folder() const;
  inline void set_validation_folder(const ::std::string& value);
  inline void set_validation_folder(const char* value);
  inline void set_validation_folder(const char* value, size_t size);
  inline ::std::string* mutable_validation_folder();
  inline ::std::string* release_validation_folder();
  inline void set_allocated_validation_folder(::std::string* validation_folder);

  // optional int32 display_after_steps = 6 [default = 0];
  inline bool has_display_after_steps() const;
  inline void clear_display_after_steps();
  static const int kDisplayAfterStepsFieldNumber = 6;
  inline ::google::protobuf::int32 display_after_steps() const;
  inline void set_display_after_steps(::google::protobuf::int32 value);

  // optional int32 display_frequency = 7 [default = 0];
  inline bool has_display_frequency() const;
  inline void clear_display_frequency();
  static const int kDisplayFrequencyFieldNumber = 7;
  inline ::google::protobuf::int32 display_frequency() const;
  inline void set_display_frequency(::google::protobuf::int32 value);

  // optional int32 validation_after_steps = 10 [default = 0];
  inline bool has_validation_after_steps() const;
  inline void clear_validation_after_steps();
  static const int kValidationAfterStepsFieldNumber = 10;
  inline ::google::protobuf::int32 validation_after_steps() const;
  inline void set_validation_after_steps(::google::protobuf::int32 value);

  // optional int32 validation_frequency = 11 [default = 0];
  inline bool has_validation_frequency() const;
  inline void clear_validation_frequency();
  static const int kValidationFrequencyFieldNumber = 11;
  inline ::google::protobuf::int32 validation_frequency() const;
  inline void set_validation_frequency(::google::protobuf::int32 value);

  // optional int32 test_after_steps = 13 [default = 0];
  inline bool has_test_after_steps() const;
  inline void clear_test_after_steps();
  static const int kTestAfterStepsFieldNumber = 13;
  inline ::google::protobuf::int32 test_after_steps() const;
  inline void set_test_after_steps(::google::protobuf::int32 value);

  // optional int32 test_frequency = 14 [default = 0];
  inline bool has_test_frequency() const;
  inline void clear_test_frequency();
  static const int kTestFrequencyFieldNumber = 14;
  inline ::google::protobuf::int32 test_frequency() const;
  inline void set_test_frequency(::google::protobuf::int32 value);

  // optional int32 checkpoint_after_steps = 15 [default = 0];
  inline bool has_checkpoint_after_steps() const;
  inline void clear_checkpoint_after_steps();
  static const int kCheckpointAfterStepsFieldNumber = 15;
  inline ::google::protobuf::int32 checkpoint_after_steps() const;
  inline void set_checkpoint_after_steps(::google::protobuf::int32 value);

  // optional int32 checkpoint_frequency = 16 [default = 0];
  inline bool has_checkpoint_frequency() const;
  inline void clear_checkpoint_frequency();
  static const int kCheckpointFrequencyFieldNumber = 16;
  inline ::google::protobuf::int32 checkpoint_frequency() const;
  inline void set_checkpoint_frequency(::google::protobuf::int32 value);

  // optional bool prefetch = 18 [default = true];
  inline bool has_prefetch() const;
  inline void clear_prefetch();
  static const int kPrefetchFieldNumber = 18;
  inline bool prefetch() const;
  inline void set_prefetch(bool value);

  // optional int32 train_steps = 20;
  inline bool has_train_steps() const;
  inline void clear_train_steps();
  static const int kTrainStepsFieldNumber = 20;
  inline ::google::protobuf::int32 train_steps() const;
  inline void set_train_steps(::google::protobuf::int32 value);

  // optional int32 validation_steps = 21;
  inline bool has_validation_steps() const;
  inline void clear_validation_steps();
  static const int kValidationStepsFieldNumber = 21;
  inline ::google::protobuf::int32 validation_steps() const;
  inline void set_validation_steps(::google::protobuf::int32 value);

  // optional int32 test_steps = 22;
  inline bool has_test_steps() const;
  inline void clear_test_steps();
  static const int kTestStepsFieldNumber = 22;
  inline ::google::protobuf::int32 test_steps() const;
  inline void set_test_steps(::google::protobuf::int32 value);

  // optional int32 step = 29 [default = 0];
  inline bool has_step() const;
  inline void clear_step();
  static const int kStepFieldNumber = 29;
  inline ::google::protobuf::int32 step() const;
  inline void set_step(::google::protobuf::int32 value);

  // optional .singa.UpdaterProto updater = 31;
  inline bool has_updater() const;
  inline void clear_updater();
  static const int kUpdaterFieldNumber = 31;
  inline const ::singa::UpdaterProto& updater() const;
  inline ::singa::UpdaterProto* mutable_updater();
  inline ::singa::UpdaterProto* release_updater();
  inline void set_allocated_updater(::singa::UpdaterProto* updater);

  // optional .singa.ModelProto.GradCalcAlg alg = 32 [default = kBackPropagation];
  inline bool has_alg() const;
  inline void clear_alg();
  static const int kAlgFieldNumber = 32;
  inline ::singa::ModelProto_GradCalcAlg alg() const;
  inline void set_alg(::singa::ModelProto_GradCalcAlg value);

  // optional bool hogwild = 33 [default = false];
  inline bool has_hogwild() const;
  inline void clear_hogwild();
  static const int kHogwildFieldNumber = 33;
  inline bool hogwild() const;
  inline void set_hogwild(bool value);

  // optional .singa.NetProto neuralnet = 40;
  inline bool has_neuralnet() const;
  inline void clear_neuralnet();
  static const int kNeuralnetFieldNumber = 40;
  inline const ::singa::NetProto& neuralnet() const;
  inline ::singa::NetProto* mutable_neuralnet();
  inline ::singa::NetProto* release_neuralnet();
  inline void set_allocated_neuralnet(::singa::NetProto* neuralnet);

  // optional bool debug = 41 [default = false];
  inline bool has_debug() const;
  inline void clear_debug();
  static const int kDebugFieldNumber = 41;
  inline bool debug() const;
  inline void set_debug(bool value);

  // optional int32 warmup_steps = 50 [default = 0];
  inline bool has_warmup_steps() const;
  inline void clear_warmup_steps();
  static const int kWarmupStepsFieldNumber = 50;
  inline ::google::protobuf::int32 warmup_steps() const;
  inline void set_warmup_steps(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:singa.ModelProto)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_train_folder();
  inline void clear_has_train_folder();
  inline void set_has_test_folder();
  inline void clear_has_test_folder();
  inline void set_has_validation_folder();
  inline void clear_has_validation_folder();
  inline void set_has_display_after_steps();
  inline void clear_has_display_after_steps();
  inline void set_has_display_frequency();
  inline void clear_has_display_frequency();
  inline void set_has_validation_after_steps();
  inline void clear_has_validation_after_steps();
  inline void set_has_validation_frequency();
  inline void clear_has_validation_frequency();
  inline void set_has_test_after_steps();
  inline void clear_has_test_after_steps();
  inline void set_has_test_frequency();
  inline void clear_has_test_frequency();
  inline void set_has_checkpoint_after_steps();
  inline void clear_has_checkpoint_after_steps();
  inline void set_has_checkpoint_frequency();
  inline void clear_has_checkpoint_frequency();
  inline void set_has_prefetch();
  inline void clear_has_prefetch();
  inline void set_has_train_steps();
  inline void clear_has_train_steps();
  inline void set_has_validation_steps();
  inline void clear_has_validation_steps();
  inline void set_has_test_steps();
  inline void clear_has_test_steps();
  inline void set_has_step();
  inline void clear_has_step();
  inline void set_has_updater();
  inline void clear_has_updater();
  inline void set_has_alg();
  inline void clear_has_alg();
  inline void set_has_hogwild();
  inline void clear_has_hogwild();
  inline void set_has_neuralnet();
  inline void clear_has_neuralnet();
  inline void set_has_debug();
  inline void clear_has_debug();
  inline void set_has_warmup_steps();
  inline void clear_has_warmup_steps();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::std::string* train_folder_;
  static ::std::string* _default_train_folder_;
  ::std::string* test_folder_;
  static ::std::string* _default_test_folder_;
  ::std::string* validation_folder_;
  static ::std::string* _default_validation_folder_;
  ::google::protobuf::int32 display_after_steps_;
  ::google::protobuf::int32 display_frequency_;
  ::google::protobuf::int32 validation_after_steps_;
  ::google::protobuf::int32 validation_frequency_;
  ::google::protobuf::int32 test_after_steps_;
  ::google::protobuf::int32 test_frequency_;
  ::google::protobuf::int32 checkpoint_after_steps_;
  ::google::protobuf::int32 checkpoint_frequency_;
  ::google::protobuf::int32 train_steps_;
  ::google::protobuf::int32 validation_steps_;
  ::google::protobuf::int32 test_steps_;
  ::google::protobuf::int32 step_;
  ::singa::UpdaterProto* updater_;
  bool prefetch_;
  bool hogwild_;
  bool debug_;
  int alg_;
  ::singa::NetProto* neuralnet_;
  ::google::protobuf::int32 warmup_steps_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(23 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static ModelProto* default_instance_;
};
// -------------------------------------------------------------------

class NetProto : public ::google::protobuf::Message {
 public:
  NetProto();
  virtual ~NetProto();

  NetProto(const NetProto& from);

  inline NetProto& operator=(const NetProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NetProto& default_instance();

  void Swap(NetProto* other);

  // implements Message ----------------------------------------------

  NetProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NetProto& from);
  void MergeFrom(const NetProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .singa.LayerProto layer = 1;
  inline int layer_size() const;
  inline void clear_layer();
  static const int kLayerFieldNumber = 1;
  inline const ::singa::LayerProto& layer(int index) const;
  inline ::singa::LayerProto* mutable_layer(int index);
  inline ::singa::LayerProto* add_layer();
  inline const ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >&
      layer() const;
  inline ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >*
      mutable_layer();

  // optional .singa.PartitionType partition_type = 3 [default = kNone];
  inline bool has_partition_type() const;
  inline void clear_partition_type();
  static const int kPartitionTypeFieldNumber = 3;
  inline ::singa::PartitionType partition_type() const;
  inline void set_partition_type(::singa::PartitionType value);

  // @@protoc_insertion_point(class_scope:singa.NetProto)
 private:
  inline void set_has_partition_type();
  inline void clear_has_partition_type();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::singa::LayerProto > layer_;
  int partition_type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static NetProto* default_instance_;
};
// -------------------------------------------------------------------

class ParamProto : public ::google::protobuf::Message {
 public:
  ParamProto();
  virtual ~ParamProto();

  ParamProto(const ParamProto& from);

  inline ParamProto& operator=(const ParamProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ParamProto& default_instance();

  void Swap(ParamProto* other);

  // implements Message ----------------------------------------------

  ParamProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ParamProto& from);
  void MergeFrom(const ParamProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef ParamProto_InitMethod InitMethod;
  static const InitMethod kConstant = ParamProto_InitMethod_kConstant;
  static const InitMethod kGaussian = ParamProto_InitMethod_kGaussian;
  static const InitMethod kUniform = ParamProto_InitMethod_kUniform;
  static const InitMethod kPretrained = ParamProto_InitMethod_kPretrained;
  static const InitMethod kGaussainSqrtFanIn = ParamProto_InitMethod_kGaussainSqrtFanIn;
  static const InitMethod kUniformSqrtFanIn = ParamProto_InitMethod_kUniformSqrtFanIn;
  static const InitMethod kUniformSqrtFanInOut = ParamProto_InitMethod_kUniformSqrtFanInOut;
  static inline bool InitMethod_IsValid(int value) {
    return ParamProto_InitMethod_IsValid(value);
  }
  static const InitMethod InitMethod_MIN =
    ParamProto_InitMethod_InitMethod_MIN;
  static const InitMethod InitMethod_MAX =
    ParamProto_InitMethod_InitMethod_MAX;
  static const int InitMethod_ARRAYSIZE =
    ParamProto_InitMethod_InitMethod_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  InitMethod_descriptor() {
    return ParamProto_InitMethod_descriptor();
  }
  static inline const ::std::string& InitMethod_Name(InitMethod value) {
    return ParamProto_InitMethod_Name(value);
  }
  static inline bool InitMethod_Parse(const ::std::string& name,
      InitMethod* value) {
    return ParamProto_InitMethod_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // optional int32 id = 2;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 2;
  inline ::google::protobuf::int32 id() const;
  inline void set_id(::google::protobuf::int32 value);

  // repeated int32 shape = 3;
  inline int shape_size() const;
  inline void clear_shape();
  static const int kShapeFieldNumber = 3;
  inline ::google::protobuf::int32 shape(int index) const;
  inline void set_shape(int index, ::google::protobuf::int32 value);
  inline void add_shape(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      shape() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_shape();

  // optional int32 split_threshold = 4 [default = 5000000];
  inline bool has_split_threshold() const;
  inline void clear_split_threshold();
  static const int kSplitThresholdFieldNumber = 4;
  inline ::google::protobuf::int32 split_threshold() const;
  inline void set_split_threshold(::google::protobuf::int32 value);

  // optional int32 partition_dim = 5 [default = -1];
  inline bool has_partition_dim() const;
  inline void clear_partition_dim();
  static const int kPartitionDimFieldNumber = 5;
  inline ::google::protobuf::int32 partition_dim() const;
  inline void set_partition_dim(::google::protobuf::int32 value);

  // optional int32 owner = 6;
  inline bool has_owner() const;
  inline void clear_owner();
  static const int kOwnerFieldNumber = 6;
  inline ::google::protobuf::int32 owner() const;
  inline void set_owner(::google::protobuf::int32 value);

  // optional .singa.ParamProto.InitMethod init_method = 7 [default = kConstant];
  inline bool has_init_method() const;
  inline void clear_init_method();
  static const int kInitMethodFieldNumber = 7;
  inline ::singa::ParamProto_InitMethod init_method() const;
  inline void set_init_method(::singa::ParamProto_InitMethod value);

  // optional float value = 8 [default = 1];
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 8;
  inline float value() const;
  inline void set_value(float value);

  // optional float low = 9 [default = -1];
  inline bool has_low() const;
  inline void clear_low();
  static const int kLowFieldNumber = 9;
  inline float low() const;
  inline void set_low(float value);

  // optional float high = 10 [default = 1];
  inline bool has_high() const;
  inline void clear_high();
  static const int kHighFieldNumber = 10;
  inline float high() const;
  inline void set_high(float value);

  // optional float mean = 11 [default = 0];
  inline bool has_mean() const;
  inline void clear_mean();
  static const int kMeanFieldNumber = 11;
  inline float mean() const;
  inline void set_mean(float value);

  // optional float std = 12 [default = 1];
  inline bool has_std() const;
  inline void clear_std();
  static const int kStdFieldNumber = 12;
  inline float std() const;
  inline void set_std(float value);

  // optional float learning_rate_multiplier = 13 [default = 1];
  inline bool has_learning_rate_multiplier() const;
  inline void clear_learning_rate_multiplier();
  static const int kLearningRateMultiplierFieldNumber = 13;
  inline float learning_rate_multiplier() const;
  inline void set_learning_rate_multiplier(float value);

  // optional float weight_decay_multiplier = 14 [default = 1];
  inline bool has_weight_decay_multiplier() const;
  inline void clear_weight_decay_multiplier();
  static const int kWeightDecayMultiplierFieldNumber = 14;
  inline float weight_decay_multiplier() const;
  inline void set_weight_decay_multiplier(float value);

  // @@protoc_insertion_point(class_scope:singa.ParamProto)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_id();
  inline void clear_has_id();
  inline void set_has_split_threshold();
  inline void clear_has_split_threshold();
  inline void set_has_partition_dim();
  inline void clear_has_partition_dim();
  inline void set_has_owner();
  inline void clear_has_owner();
  inline void set_has_init_method();
  inline void clear_has_init_method();
  inline void set_has_value();
  inline void clear_has_value();
  inline void set_has_low();
  inline void clear_has_low();
  inline void set_has_high();
  inline void clear_has_high();
  inline void set_has_mean();
  inline void clear_has_mean();
  inline void set_has_std();
  inline void clear_has_std();
  inline void set_has_learning_rate_multiplier();
  inline void clear_has_learning_rate_multiplier();
  inline void set_has_weight_decay_multiplier();
  inline void clear_has_weight_decay_multiplier();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > shape_;
  ::google::protobuf::int32 id_;
  ::google::protobuf::int32 split_threshold_;
  ::google::protobuf::int32 partition_dim_;
  ::google::protobuf::int32 owner_;
  int init_method_;
  float value_;
  float low_;
  float high_;
  float mean_;
  float std_;
  float learning_rate_multiplier_;
  float weight_decay_multiplier_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(14 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static ParamProto* default_instance_;
};
// -------------------------------------------------------------------

class BlobProtos : public ::google::protobuf::Message {
 public:
  BlobProtos();
  virtual ~BlobProtos();

  BlobProtos(const BlobProtos& from);

  inline BlobProtos& operator=(const BlobProtos& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlobProtos& default_instance();

  void Swap(BlobProtos* other);

  // implements Message ----------------------------------------------

  BlobProtos* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlobProtos& from);
  void MergeFrom(const BlobProtos& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .singa.BlobProto blobs = 1;
  inline int blobs_size() const;
  inline void clear_blobs();
  static const int kBlobsFieldNumber = 1;
  inline const ::singa::BlobProto& blobs(int index) const;
  inline ::singa::BlobProto* mutable_blobs(int index);
  inline ::singa::BlobProto* add_blobs();
  inline const ::google::protobuf::RepeatedPtrField< ::singa::BlobProto >&
      blobs() const;
  inline ::google::protobuf::RepeatedPtrField< ::singa::BlobProto >*
      mutable_blobs();

  // repeated int32 ids = 2;
  inline int ids_size() const;
  inline void clear_ids();
  static const int kIdsFieldNumber = 2;
  inline ::google::protobuf::int32 ids(int index) const;
  inline void set_ids(int index, ::google::protobuf::int32 value);
  inline void add_ids(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      ids() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_ids();

  // repeated string names = 3;
  inline int names_size() const;
  inline void clear_names();
  static const int kNamesFieldNumber = 3;
  inline const ::std::string& names(int index) const;
  inline ::std::string* mutable_names(int index);
  inline void set_names(int index, const ::std::string& value);
  inline void set_names(int index, const char* value);
  inline void set_names(int index, const char* value, size_t size);
  inline ::std::string* add_names();
  inline void add_names(const ::std::string& value);
  inline void add_names(const char* value);
  inline void add_names(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& names() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_names();

  // @@protoc_insertion_point(class_scope:singa.BlobProtos)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::singa::BlobProto > blobs_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > ids_;
  ::google::protobuf::RepeatedPtrField< ::std::string> names_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static BlobProtos* default_instance_;
};
// -------------------------------------------------------------------

class LayerProto : public ::google::protobuf::Message {
 public:
  LayerProto();
  virtual ~LayerProto();

  LayerProto(const LayerProto& from);

  inline LayerProto& operator=(const LayerProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LayerProto& default_instance();

  void Swap(LayerProto* other);

  // implements Message ----------------------------------------------

  LayerProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LayerProto& from);
  void MergeFrom(const LayerProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // optional string type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline const ::std::string& type() const;
  inline void set_type(const ::std::string& value);
  inline void set_type(const char* value);
  inline void set_type(const char* value, size_t size);
  inline ::std::string* mutable_type();
  inline ::std::string* release_type();
  inline void set_allocated_type(::std::string* type);

  // repeated string srclayers = 3;
  inline int srclayers_size() const;
  inline void clear_srclayers();
  static const int kSrclayersFieldNumber = 3;
  inline const ::std::string& srclayers(int index) const;
  inline ::std::string* mutable_srclayers(int index);
  inline void set_srclayers(int index, const ::std::string& value);
  inline void set_srclayers(int index, const char* value);
  inline void set_srclayers(int index, const char* value, size_t size);
  inline ::std::string* add_srclayers();
  inline void add_srclayers(const ::std::string& value);
  inline void add_srclayers(const char* value);
  inline void add_srclayers(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& srclayers() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_srclayers();

  // optional int32 locationid = 4 [default = 0];
  inline bool has_locationid() const;
  inline void clear_locationid();
  static const int kLocationidFieldNumber = 4;
  inline ::google::protobuf::int32 locationid() const;
  inline void set_locationid(::google::protobuf::int32 value);

  // optional int32 partitionid = 5 [default = 0];
  inline bool has_partitionid() const;
  inline void clear_partitionid();
  static const int kPartitionidFieldNumber = 5;
  inline ::google::protobuf::int32 partitionid() const;
  inline void set_partitionid(::google::protobuf::int32 value);

  // optional .singa.PartitionType partition_type = 6;
  inline bool has_partition_type() const;
  inline void clear_partition_type();
  static const int kPartitionTypeFieldNumber = 6;
  inline ::singa::PartitionType partition_type() const;
  inline void set_partition_type(::singa::PartitionType value);

  // optional string datablob = 7;
  inline bool has_datablob() const;
  inline void clear_datablob();
  static const int kDatablobFieldNumber = 7;
  inline const ::std::string& datablob() const;
  inline void set_datablob(const ::std::string& value);
  inline void set_datablob(const char* value);
  inline void set_datablob(const char* value, size_t size);
  inline ::std::string* mutable_datablob();
  inline ::std::string* release_datablob();
  inline void set_allocated_datablob(::std::string* datablob);

  // repeated string share_ary = 11;
  inline int share_ary_size() const;
  inline void clear_share_ary();
  static const int kShareAryFieldNumber = 11;
  inline const ::std::string& share_ary(int index) const;
  inline ::std::string* mutable_share_ary(int index);
  inline void set_share_ary(int index, const ::std::string& value);
  inline void set_share_ary(int index, const char* value);
  inline void set_share_ary(int index, const char* value, size_t size);
  inline ::std::string* add_share_ary();
  inline void add_share_ary(const ::std::string& value);
  inline void add_share_ary(const char* value);
  inline void add_share_ary(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& share_ary() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_share_ary();

  // repeated .singa.ParamProto param = 12;
  inline int param_size() const;
  inline void clear_param();
  static const int kParamFieldNumber = 12;
  inline const ::singa::ParamProto& param(int index) const;
  inline ::singa::ParamProto* mutable_param(int index);
  inline ::singa::ParamProto* add_param();
  inline const ::google::protobuf::RepeatedPtrField< ::singa::ParamProto >&
      param() const;
  inline ::google::protobuf::RepeatedPtrField< ::singa::ParamProto >*
      mutable_param();

  // repeated string share_param = 13;
  inline int share_param_size() const;
  inline void clear_share_param();
  static const int kShareParamFieldNumber = 13;
  inline const ::std::string& share_param(int index) const;
  inline ::std::string* mutable_share_param(int index);
  inline void set_share_param(int index, const ::std::string& value);
  inline void set_share_param(int index, const char* value);
  inline void set_share_param(int index, const char* value, size_t size);
  inline ::std::string* add_share_param();
  inline void add_share_param(const ::std::string& value);
  inline void add_share_param(const char* value);
  inline void add_share_param(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& share_param() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_share_param();

  // repeated .singa.Phase exclude = 20;
  inline int exclude_size() const;
  inline void clear_exclude();
  static const int kExcludeFieldNumber = 20;
  inline ::singa::Phase exclude(int index) const;
  inline void set_exclude(int index, ::singa::Phase value);
  inline void add_exclude(::singa::Phase value);
  inline const ::google::protobuf::RepeatedField<int>& exclude() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_exclude();

  // optional .singa.ConvolutionProto convolution_param = 21;
  inline bool has_convolution_param() const;
  inline void clear_convolution_param();
  static const int kConvolutionParamFieldNumber = 21;
  inline const ::singa::ConvolutionProto& convolution_param() const;
  inline ::singa::ConvolutionProto* mutable_convolution_param();
  inline ::singa::ConvolutionProto* release_convolution_param();
  inline void set_allocated_convolution_param(::singa::ConvolutionProto* convolution_param);

  // optional .singa.ConcateProto concate_param = 31;
  inline bool has_concate_param() const;
  inline void clear_concate_param();
  static const int kConcateParamFieldNumber = 31;
  inline const ::singa::ConcateProto& concate_param() const;
  inline ::singa::ConcateProto* mutable_concate_param();
  inline ::singa::ConcateProto* release_concate_param();
  inline void set_allocated_concate_param(::singa::ConcateProto* concate_param);

  // optional .singa.DataProto data_param = 22;
  inline bool has_data_param() const;
  inline void clear_data_param();
  static const int kDataParamFieldNumber = 22;
  inline const ::singa::DataProto& data_param() const;
  inline ::singa::DataProto* mutable_data_param();
  inline ::singa::DataProto* release_data_param();
  inline void set_allocated_data_param(::singa::DataProto* data_param);

  // optional .singa.DropoutProto dropout_param = 23;
  inline bool has_dropout_param() const;
  inline void clear_dropout_param();
  static const int kDropoutParamFieldNumber = 23;
  inline const ::singa::DropoutProto& dropout_param() const;
  inline ::singa::DropoutProto* mutable_dropout_param();
  inline ::singa::DropoutProto* release_dropout_param();
  inline void set_allocated_dropout_param(::singa::DropoutProto* dropout_param);

  // optional .singa.InnerProductProto inner_product_param = 24;
  inline bool has_inner_product_param() const;
  inline void clear_inner_product_param();
  static const int kInnerProductParamFieldNumber = 24;
  inline const ::singa::InnerProductProto& inner_product_param() const;
  inline ::singa::InnerProductProto* mutable_inner_product_param();
  inline ::singa::InnerProductProto* release_inner_product_param();
  inline void set_allocated_inner_product_param(::singa::InnerProductProto* inner_product_param);

  // optional .singa.LRNProto lrn_param = 25;
  inline bool has_lrn_param() const;
  inline void clear_lrn_param();
  static const int kLrnParamFieldNumber = 25;
  inline const ::singa::LRNProto& lrn_param() const;
  inline ::singa::LRNProto* mutable_lrn_param();
  inline ::singa::LRNProto* release_lrn_param();
  inline void set_allocated_lrn_param(::singa::LRNProto* lrn_param);

  // optional .singa.MnistProto mnist_param = 26;
  inline bool has_mnist_param() const;
  inline void clear_mnist_param();
  static const int kMnistParamFieldNumber = 26;
  inline const ::singa::MnistProto& mnist_param() const;
  inline ::singa::MnistProto* mutable_mnist_param();
  inline ::singa::MnistProto* release_mnist_param();
  inline void set_allocated_mnist_param(::singa::MnistProto* mnist_param);

  // optional .singa.PoolingProto pooling_param = 27;
  inline bool has_pooling_param() const;
  inline void clear_pooling_param();
  static const int kPoolingParamFieldNumber = 27;
  inline const ::singa::PoolingProto& pooling_param() const;
  inline ::singa::PoolingProto* mutable_pooling_param();
  inline ::singa::PoolingProto* release_pooling_param();
  inline void set_allocated_pooling_param(::singa::PoolingProto* pooling_param);

  // repeated .singa.LayerProto sublayers = 35;
  inline int sublayers_size() const;
  inline void clear_sublayers();
  static const int kSublayersFieldNumber = 35;
  inline const ::singa::LayerProto& sublayers(int index) const;
  inline ::singa::LayerProto* mutable_sublayers(int index);
  inline ::singa::LayerProto* add_sublayers();
  inline const ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >&
      sublayers() const;
  inline ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >*
      mutable_sublayers();

  // optional .singa.SliceProto slice_param = 32;
  inline bool has_slice_param() const;
  inline void clear_slice_param();
  static const int kSliceParamFieldNumber = 32;
  inline const ::singa::SliceProto& slice_param() const;
  inline ::singa::SliceProto* mutable_slice_param();
  inline ::singa::SliceProto* release_slice_param();
  inline void set_allocated_slice_param(::singa::SliceProto* slice_param);

  // optional .singa.SplitProto split_param = 33;
  inline bool has_split_param() const;
  inline void clear_split_param();
  static const int kSplitParamFieldNumber = 33;
  inline const ::singa::SplitProto& split_param() const;
  inline ::singa::SplitProto* mutable_split_param();
  inline ::singa::SplitProto* release_split_param();
  inline void set_allocated_split_param(::singa::SplitProto* split_param);

  // optional .singa.ReLUProto relu_param = 28;
  inline bool has_relu_param() const;
  inline void clear_relu_param();
  static const int kReluParamFieldNumber = 28;
  inline const ::singa::ReLUProto& relu_param() const;
  inline ::singa::ReLUProto* mutable_relu_param();
  inline ::singa::ReLUProto* release_relu_param();
  inline void set_allocated_relu_param(::singa::ReLUProto* relu_param);

  // optional .singa.RGBImage rgbimage_param = 34;
  inline bool has_rgbimage_param() const;
  inline void clear_rgbimage_param();
  static const int kRgbimageParamFieldNumber = 34;
  inline const ::singa::RGBImage& rgbimage_param() const;
  inline ::singa::RGBImage* mutable_rgbimage_param();
  inline ::singa::RGBImage* release_rgbimage_param();
  inline void set_allocated_rgbimage_param(::singa::RGBImage* rgbimage_param);

  // optional .singa.SoftmaxLossProto softmaxloss_param = 29;
  inline bool has_softmaxloss_param() const;
  inline void clear_softmaxloss_param();
  static const int kSoftmaxlossParamFieldNumber = 29;
  inline const ::singa::SoftmaxLossProto& softmaxloss_param() const;
  inline ::singa::SoftmaxLossProto* mutable_softmaxloss_param();
  inline ::singa::SoftmaxLossProto* release_softmaxloss_param();
  inline void set_allocated_softmaxloss_param(::singa::SoftmaxLossProto* softmaxloss_param);

  // optional .singa.TanhProto tanh_param = 30;
  inline bool has_tanh_param() const;
  inline void clear_tanh_param();
  static const int kTanhParamFieldNumber = 30;
  inline const ::singa::TanhProto& tanh_param() const;
  inline ::singa::TanhProto* mutable_tanh_param();
  inline ::singa::TanhProto* release_tanh_param();
  inline void set_allocated_tanh_param(::singa::TanhProto* tanh_param);

  // @@protoc_insertion_point(class_scope:singa.LayerProto)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_locationid();
  inline void clear_has_locationid();
  inline void set_has_partitionid();
  inline void clear_has_partitionid();
  inline void set_has_partition_type();
  inline void clear_has_partition_type();
  inline void set_has_datablob();
  inline void clear_has_datablob();
  inline void set_has_convolution_param();
  inline void clear_has_convolution_param();
  inline void set_has_concate_param();
  inline void clear_has_concate_param();
  inline void set_has_data_param();
  inline void clear_has_data_param();
  inline void set_has_dropout_param();
  inline void clear_has_dropout_param();
  inline void set_has_inner_product_param();
  inline void clear_has_inner_product_param();
  inline void set_has_lrn_param();
  inline void clear_has_lrn_param();
  inline void set_has_mnist_param();
  inline void clear_has_mnist_param();
  inline void set_has_pooling_param();
  inline void clear_has_pooling_param();
  inline void set_has_slice_param();
  inline void clear_has_slice_param();
  inline void set_has_split_param();
  inline void clear_has_split_param();
  inline void set_has_relu_param();
  inline void clear_has_relu_param();
  inline void set_has_rgbimage_param();
  inline void clear_has_rgbimage_param();
  inline void set_has_softmaxloss_param();
  inline void clear_has_softmaxloss_param();
  inline void set_has_tanh_param();
  inline void clear_has_tanh_param();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::std::string* type_;
  ::google::protobuf::RepeatedPtrField< ::std::string> srclayers_;
  ::google::protobuf::int32 locationid_;
  ::google::protobuf::int32 partitionid_;
  ::std::string* datablob_;
  ::google::protobuf::RepeatedPtrField< ::std::string> share_ary_;
  ::google::protobuf::RepeatedPtrField< ::singa::ParamProto > param_;
  ::google::protobuf::RepeatedPtrField< ::std::string> share_param_;
  ::google::protobuf::RepeatedField<int> exclude_;
  ::singa::ConvolutionProto* convolution_param_;
  ::singa::ConcateProto* concate_param_;
  ::singa::DataProto* data_param_;
  ::singa::DropoutProto* dropout_param_;
  ::singa::InnerProductProto* inner_product_param_;
  ::singa::LRNProto* lrn_param_;
  ::singa::MnistProto* mnist_param_;
  ::singa::PoolingProto* pooling_param_;
  ::google::protobuf::RepeatedPtrField< ::singa::LayerProto > sublayers_;
  ::singa::SliceProto* slice_param_;
  ::singa::SplitProto* split_param_;
  ::singa::ReLUProto* relu_param_;
  ::singa::RGBImage* rgbimage_param_;
  ::singa::SoftmaxLossProto* softmaxloss_param_;
  ::singa::TanhProto* tanh_param_;
  int partition_type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(26 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static LayerProto* default_instance_;
};
// -------------------------------------------------------------------

class RGBImage : public ::google::protobuf::Message {
 public:
  RGBImage();
  virtual ~RGBImage();

  RGBImage(const RGBImage& from);

  inline RGBImage& operator=(const RGBImage& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RGBImage& default_instance();

  void Swap(RGBImage* other);

  // implements Message ----------------------------------------------

  RGBImage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RGBImage& from);
  void MergeFrom(const RGBImage& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional float scale = 1 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 1;
  inline float scale() const;
  inline void set_scale(float value);

  // optional int32 cropsize = 2 [default = 0];
  inline bool has_cropsize() const;
  inline void clear_cropsize();
  static const int kCropsizeFieldNumber = 2;
  inline ::google::protobuf::int32 cropsize() const;
  inline void set_cropsize(::google::protobuf::int32 value);

  // optional bool mirror = 3 [default = false];
  inline bool has_mirror() const;
  inline void clear_mirror();
  static const int kMirrorFieldNumber = 3;
  inline bool mirror() const;
  inline void set_mirror(bool value);

  // optional string meanfile = 4;
  inline bool has_meanfile() const;
  inline void clear_meanfile();
  static const int kMeanfileFieldNumber = 4;
  inline const ::std::string& meanfile() const;
  inline void set_meanfile(const ::std::string& value);
  inline void set_meanfile(const char* value);
  inline void set_meanfile(const char* value, size_t size);
  inline ::std::string* mutable_meanfile();
  inline ::std::string* release_meanfile();
  inline void set_allocated_meanfile(::std::string* meanfile);

  // @@protoc_insertion_point(class_scope:singa.RGBImage)
 private:
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_cropsize();
  inline void clear_has_cropsize();
  inline void set_has_mirror();
  inline void clear_has_mirror();
  inline void set_has_meanfile();
  inline void clear_has_meanfile();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float scale_;
  ::google::protobuf::int32 cropsize_;
  ::std::string* meanfile_;
  bool mirror_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static RGBImage* default_instance_;
};
// -------------------------------------------------------------------

class SplitProto : public ::google::protobuf::Message {
 public:
  SplitProto();
  virtual ~SplitProto();

  SplitProto(const SplitProto& from);

  inline SplitProto& operator=(const SplitProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SplitProto& default_instance();

  void Swap(SplitProto* other);

  // implements Message ----------------------------------------------

  SplitProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SplitProto& from);
  void MergeFrom(const SplitProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 num_splits = 1;
  inline bool has_num_splits() const;
  inline void clear_num_splits();
  static const int kNumSplitsFieldNumber = 1;
  inline ::google::protobuf::int32 num_splits() const;
  inline void set_num_splits(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:singa.SplitProto)
 private:
  inline void set_has_num_splits();
  inline void clear_has_num_splits();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 num_splits_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static SplitProto* default_instance_;
};
// -------------------------------------------------------------------

class TanhProto : public ::google::protobuf::Message {
 public:
  TanhProto();
  virtual ~TanhProto();

  TanhProto(const TanhProto& from);

  inline TanhProto& operator=(const TanhProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TanhProto& default_instance();

  void Swap(TanhProto* other);

  // implements Message ----------------------------------------------

  TanhProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TanhProto& from);
  void MergeFrom(const TanhProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional float outer_scale = 1 [default = 1];
  inline bool has_outer_scale() const;
  inline void clear_outer_scale();
  static const int kOuterScaleFieldNumber = 1;
  inline float outer_scale() const;
  inline void set_outer_scale(float value);

  // optional float inner_scale = 2 [default = 1];
  inline bool has_inner_scale() const;
  inline void clear_inner_scale();
  static const int kInnerScaleFieldNumber = 2;
  inline float inner_scale() const;
  inline void set_inner_scale(float value);

  // @@protoc_insertion_point(class_scope:singa.TanhProto)
 private:
  inline void set_has_outer_scale();
  inline void clear_has_outer_scale();
  inline void set_has_inner_scale();
  inline void clear_has_inner_scale();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float outer_scale_;
  float inner_scale_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static TanhProto* default_instance_;
};
// -------------------------------------------------------------------

class SoftmaxLossProto : public ::google::protobuf::Message {
 public:
  SoftmaxLossProto();
  virtual ~SoftmaxLossProto();

  SoftmaxLossProto(const SoftmaxLossProto& from);

  inline SoftmaxLossProto& operator=(const SoftmaxLossProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SoftmaxLossProto& default_instance();

  void Swap(SoftmaxLossProto* other);

  // implements Message ----------------------------------------------

  SoftmaxLossProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SoftmaxLossProto& from);
  void MergeFrom(const SoftmaxLossProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 topk = 1 [default = 1];
  inline bool has_topk() const;
  inline void clear_topk();
  static const int kTopkFieldNumber = 1;
  inline ::google::protobuf::int32 topk() const;
  inline void set_topk(::google::protobuf::int32 value);

  // optional float scale = 2 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline float scale() const;
  inline void set_scale(float value);

  // @@protoc_insertion_point(class_scope:singa.SoftmaxLossProto)
 private:
  inline void set_has_topk();
  inline void clear_has_topk();
  inline void set_has_scale();
  inline void clear_has_scale();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 topk_;
  float scale_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static SoftmaxLossProto* default_instance_;
};
// -------------------------------------------------------------------

class ConvolutionProto : public ::google::protobuf::Message {
 public:
  ConvolutionProto();
  virtual ~ConvolutionProto();

  ConvolutionProto(const ConvolutionProto& from);

  inline ConvolutionProto& operator=(const ConvolutionProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ConvolutionProto& default_instance();

  void Swap(ConvolutionProto* other);

  // implements Message ----------------------------------------------

  ConvolutionProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ConvolutionProto& from);
  void MergeFrom(const ConvolutionProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 num_filters = 1;
  inline bool has_num_filters() const;
  inline void clear_num_filters();
  static const int kNumFiltersFieldNumber = 1;
  inline ::google::protobuf::uint32 num_filters() const;
  inline void set_num_filters(::google::protobuf::uint32 value);

  // optional bool bias_term = 2 [default = true];
  inline bool has_bias_term() const;
  inline void clear_bias_term();
  static const int kBiasTermFieldNumber = 2;
  inline bool bias_term() const;
  inline void set_bias_term(bool value);

  // optional uint32 pad = 3 [default = 0];
  inline bool has_pad() const;
  inline void clear_pad();
  static const int kPadFieldNumber = 3;
  inline ::google::protobuf::uint32 pad() const;
  inline void set_pad(::google::protobuf::uint32 value);

  // optional uint32 stride = 4 [default = 1];
  inline bool has_stride() const;
  inline void clear_stride();
  static const int kStrideFieldNumber = 4;
  inline ::google::protobuf::uint32 stride() const;
  inline void set_stride(::google::protobuf::uint32 value);

  // required uint32 kernel = 5;
  inline bool has_kernel() const;
  inline void clear_kernel();
  static const int kKernelFieldNumber = 5;
  inline ::google::protobuf::uint32 kernel() const;
  inline void set_kernel(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:singa.ConvolutionProto)
 private:
  inline void set_has_num_filters();
  inline void clear_has_num_filters();
  inline void set_has_bias_term();
  inline void clear_has_bias_term();
  inline void set_has_pad();
  inline void clear_has_pad();
  inline void set_has_stride();
  inline void clear_has_stride();
  inline void set_has_kernel();
  inline void clear_has_kernel();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 num_filters_;
  bool bias_term_;
  ::google::protobuf::uint32 pad_;
  ::google::protobuf::uint32 stride_;
  ::google::protobuf::uint32 kernel_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static ConvolutionProto* default_instance_;
};
// -------------------------------------------------------------------

class ConcateProto : public ::google::protobuf::Message {
 public:
  ConcateProto();
  virtual ~ConcateProto();

  ConcateProto(const ConcateProto& from);

  inline ConcateProto& operator=(const ConcateProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ConcateProto& default_instance();

  void Swap(ConcateProto* other);

  // implements Message ----------------------------------------------

  ConcateProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ConcateProto& from);
  void MergeFrom(const ConcateProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 concate_dimension = 1;
  inline bool has_concate_dimension() const;
  inline void clear_concate_dimension();
  static const int kConcateDimensionFieldNumber = 1;
  inline ::google::protobuf::int32 concate_dimension() const;
  inline void set_concate_dimension(::google::protobuf::int32 value);

  // optional int32 concate_num = 2;
  inline bool has_concate_num() const;
  inline void clear_concate_num();
  static const int kConcateNumFieldNumber = 2;
  inline ::google::protobuf::int32 concate_num() const;
  inline void set_concate_num(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:singa.ConcateProto)
 private:
  inline void set_has_concate_dimension();
  inline void clear_has_concate_dimension();
  inline void set_has_concate_num();
  inline void clear_has_concate_num();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 concate_dimension_;
  ::google::protobuf::int32 concate_num_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static ConcateProto* default_instance_;
};
// -------------------------------------------------------------------

class DataProto : public ::google::protobuf::Message {
 public:
  DataProto();
  virtual ~DataProto();

  DataProto(const DataProto& from);

  inline DataProto& operator=(const DataProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DataProto& default_instance();

  void Swap(DataProto* other);

  // implements Message ----------------------------------------------

  DataProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DataProto& from);
  void MergeFrom(const DataProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string source = 1;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 1;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  inline ::std::string* release_source();
  inline void set_allocated_source(::std::string* source);

  // optional string path = 2;
  inline bool has_path() const;
  inline void clear_path();
  static const int kPathFieldNumber = 2;
  inline const ::std::string& path() const;
  inline void set_path(const ::std::string& value);
  inline void set_path(const char* value);
  inline void set_path(const char* value, size_t size);
  inline ::std::string* mutable_path();
  inline ::std::string* release_path();
  inline void set_allocated_path(::std::string* path);

  // optional uint32 batchsize = 4;
  inline bool has_batchsize() const;
  inline void clear_batchsize();
  static const int kBatchsizeFieldNumber = 4;
  inline ::google::protobuf::uint32 batchsize() const;
  inline void set_batchsize(::google::protobuf::uint32 value);

  // optional uint32 random_skip = 5 [default = 0];
  inline bool has_random_skip() const;
  inline void clear_random_skip();
  static const int kRandomSkipFieldNumber = 5;
  inline ::google::protobuf::uint32 random_skip() const;
  inline void set_random_skip(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:singa.DataProto)
 private:
  inline void set_has_source();
  inline void clear_has_source();
  inline void set_has_path();
  inline void clear_has_path();
  inline void set_has_batchsize();
  inline void clear_has_batchsize();
  inline void set_has_random_skip();
  inline void clear_has_random_skip();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* source_;
  ::std::string* path_;
  ::google::protobuf::uint32 batchsize_;
  ::google::protobuf::uint32 random_skip_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static DataProto* default_instance_;
};
// -------------------------------------------------------------------

class MnistProto : public ::google::protobuf::Message {
 public:
  MnistProto();
  virtual ~MnistProto();

  MnistProto(const MnistProto& from);

  inline MnistProto& operator=(const MnistProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const MnistProto& default_instance();

  void Swap(MnistProto* other);

  // implements Message ----------------------------------------------

  MnistProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MnistProto& from);
  void MergeFrom(const MnistProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 kernel = 1 [default = 0];
  inline bool has_kernel() const;
  inline void clear_kernel();
  static const int kKernelFieldNumber = 1;
  inline ::google::protobuf::int32 kernel() const;
  inline void set_kernel(::google::protobuf::int32 value);

  // optional float sigma = 2 [default = 0];
  inline bool has_sigma() const;
  inline void clear_sigma();
  static const int kSigmaFieldNumber = 2;
  inline float sigma() const;
  inline void set_sigma(float value);

  // optional float alpha = 3 [default = 0];
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 3;
  inline float alpha() const;
  inline void set_alpha(float value);

  // optional float beta = 4 [default = 0];
  inline bool has_beta() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 4;
  inline float beta() const;
  inline void set_beta(float value);

  // optional float gamma = 5 [default = 0];
  inline bool has_gamma() const;
  inline void clear_gamma();
  static const int kGammaFieldNumber = 5;
  inline float gamma() const;
  inline void set_gamma(float value);

  // optional int32 resize = 6 [default = 0];
  inline bool has_resize() const;
  inline void clear_resize();
  static const int kResizeFieldNumber = 6;
  inline ::google::protobuf::int32 resize() const;
  inline void set_resize(::google::protobuf::int32 value);

  // optional int32 elastic_freq = 7 [default = 0];
  inline bool has_elastic_freq() const;
  inline void clear_elastic_freq();
  static const int kElasticFreqFieldNumber = 7;
  inline ::google::protobuf::int32 elastic_freq() const;
  inline void set_elastic_freq(::google::protobuf::int32 value);

  // optional float norm_a = 8 [default = 1];
  inline bool has_norm_a() const;
  inline void clear_norm_a();
  static const int kNormAFieldNumber = 8;
  inline float norm_a() const;
  inline void set_norm_a(float value);

  // optional float norm_b = 9 [default = 0];
  inline bool has_norm_b() const;
  inline void clear_norm_b();
  static const int kNormBFieldNumber = 9;
  inline float norm_b() const;
  inline void set_norm_b(float value);

  // @@protoc_insertion_point(class_scope:singa.MnistProto)
 private:
  inline void set_has_kernel();
  inline void clear_has_kernel();
  inline void set_has_sigma();
  inline void clear_has_sigma();
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_beta();
  inline void clear_has_beta();
  inline void set_has_gamma();
  inline void clear_has_gamma();
  inline void set_has_resize();
  inline void clear_has_resize();
  inline void set_has_elastic_freq();
  inline void clear_has_elastic_freq();
  inline void set_has_norm_a();
  inline void clear_has_norm_a();
  inline void set_has_norm_b();
  inline void clear_has_norm_b();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 kernel_;
  float sigma_;
  float alpha_;
  float beta_;
  float gamma_;
  ::google::protobuf::int32 resize_;
  ::google::protobuf::int32 elastic_freq_;
  float norm_a_;
  float norm_b_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static MnistProto* default_instance_;
};
// -------------------------------------------------------------------

class DropoutProto : public ::google::protobuf::Message {
 public:
  DropoutProto();
  virtual ~DropoutProto();

  DropoutProto(const DropoutProto& from);

  inline DropoutProto& operator=(const DropoutProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DropoutProto& default_instance();

  void Swap(DropoutProto* other);

  // implements Message ----------------------------------------------

  DropoutProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DropoutProto& from);
  void MergeFrom(const DropoutProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional float dropout_ratio = 1 [default = 0.5];
  inline bool has_dropout_ratio() const;
  inline void clear_dropout_ratio();
  static const int kDropoutRatioFieldNumber = 1;
  inline float dropout_ratio() const;
  inline void set_dropout_ratio(float value);

  // @@protoc_insertion_point(class_scope:singa.DropoutProto)
 private:
  inline void set_has_dropout_ratio();
  inline void clear_has_dropout_ratio();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float dropout_ratio_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static DropoutProto* default_instance_;
};
// -------------------------------------------------------------------

class InnerProductProto : public ::google::protobuf::Message {
 public:
  InnerProductProto();
  virtual ~InnerProductProto();

  InnerProductProto(const InnerProductProto& from);

  inline InnerProductProto& operator=(const InnerProductProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const InnerProductProto& default_instance();

  void Swap(InnerProductProto* other);

  // implements Message ----------------------------------------------

  InnerProductProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const InnerProductProto& from);
  void MergeFrom(const InnerProductProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 num_output = 1;
  inline bool has_num_output() const;
  inline void clear_num_output();
  static const int kNumOutputFieldNumber = 1;
  inline ::google::protobuf::uint32 num_output() const;
  inline void set_num_output(::google::protobuf::uint32 value);

  // optional bool bias_term = 2 [default = true];
  inline bool has_bias_term() const;
  inline void clear_bias_term();
  static const int kBiasTermFieldNumber = 2;
  inline bool bias_term() const;
  inline void set_bias_term(bool value);

  // @@protoc_insertion_point(class_scope:singa.InnerProductProto)
 private:
  inline void set_has_num_output();
  inline void clear_has_num_output();
  inline void set_has_bias_term();
  inline void clear_has_bias_term();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 num_output_;
  bool bias_term_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static InnerProductProto* default_instance_;
};
// -------------------------------------------------------------------

class LRNProto : public ::google::protobuf::Message {
 public:
  LRNProto();
  virtual ~LRNProto();

  LRNProto(const LRNProto& from);

  inline LRNProto& operator=(const LRNProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LRNProto& default_instance();

  void Swap(LRNProto* other);

  // implements Message ----------------------------------------------

  LRNProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LRNProto& from);
  void MergeFrom(const LRNProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef LRNProto_NormRegion NormRegion;
  static const NormRegion ACROSS_CHANNELS = LRNProto_NormRegion_ACROSS_CHANNELS;
  static const NormRegion WITHIN_CHANNEL = LRNProto_NormRegion_WITHIN_CHANNEL;
  static inline bool NormRegion_IsValid(int value) {
    return LRNProto_NormRegion_IsValid(value);
  }
  static const NormRegion NormRegion_MIN =
    LRNProto_NormRegion_NormRegion_MIN;
  static const NormRegion NormRegion_MAX =
    LRNProto_NormRegion_NormRegion_MAX;
  static const int NormRegion_ARRAYSIZE =
    LRNProto_NormRegion_NormRegion_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NormRegion_descriptor() {
    return LRNProto_NormRegion_descriptor();
  }
  static inline const ::std::string& NormRegion_Name(NormRegion value) {
    return LRNProto_NormRegion_Name(value);
  }
  static inline bool NormRegion_Parse(const ::std::string& name,
      NormRegion* value) {
    return LRNProto_NormRegion_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional uint32 local_size = 1 [default = 5];
  inline bool has_local_size() const;
  inline void clear_local_size();
  static const int kLocalSizeFieldNumber = 1;
  inline ::google::protobuf::uint32 local_size() const;
  inline void set_local_size(::google::protobuf::uint32 value);

  // optional float alpha = 2 [default = 1];
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 2;
  inline float alpha() const;
  inline void set_alpha(float value);

  // optional float beta = 3 [default = 0.75];
  inline bool has_beta() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 3;
  inline float beta() const;
  inline void set_beta(float value);

  // optional .singa.LRNProto.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
  inline bool has_norm_region() const;
  inline void clear_norm_region();
  static const int kNormRegionFieldNumber = 4;
  inline ::singa::LRNProto_NormRegion norm_region() const;
  inline void set_norm_region(::singa::LRNProto_NormRegion value);

  // optional float knorm = 5 [default = 1];
  inline bool has_knorm() const;
  inline void clear_knorm();
  static const int kKnormFieldNumber = 5;
  inline float knorm() const;
  inline void set_knorm(float value);

  // @@protoc_insertion_point(class_scope:singa.LRNProto)
 private:
  inline void set_has_local_size();
  inline void clear_has_local_size();
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_beta();
  inline void clear_has_beta();
  inline void set_has_norm_region();
  inline void clear_has_norm_region();
  inline void set_has_knorm();
  inline void clear_has_knorm();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 local_size_;
  float alpha_;
  float beta_;
  int norm_region_;
  float knorm_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static LRNProto* default_instance_;
};
// -------------------------------------------------------------------

class PoolingProto : public ::google::protobuf::Message {
 public:
  PoolingProto();
  virtual ~PoolingProto();

  PoolingProto(const PoolingProto& from);

  inline PoolingProto& operator=(const PoolingProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PoolingProto& default_instance();

  void Swap(PoolingProto* other);

  // implements Message ----------------------------------------------

  PoolingProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PoolingProto& from);
  void MergeFrom(const PoolingProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef PoolingProto_PoolMethod PoolMethod;
  static const PoolMethod MAX = PoolingProto_PoolMethod_MAX;
  static const PoolMethod AVE = PoolingProto_PoolMethod_AVE;
  static inline bool PoolMethod_IsValid(int value) {
    return PoolingProto_PoolMethod_IsValid(value);
  }
  static const PoolMethod PoolMethod_MIN =
    PoolingProto_PoolMethod_PoolMethod_MIN;
  static const PoolMethod PoolMethod_MAX =
    PoolingProto_PoolMethod_PoolMethod_MAX;
  static const int PoolMethod_ARRAYSIZE =
    PoolingProto_PoolMethod_PoolMethod_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  PoolMethod_descriptor() {
    return PoolingProto_PoolMethod_descriptor();
  }
  static inline const ::std::string& PoolMethod_Name(PoolMethod value) {
    return PoolingProto_PoolMethod_Name(value);
  }
  static inline bool PoolMethod_Parse(const ::std::string& name,
      PoolMethod* value) {
    return PoolingProto_PoolMethod_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .singa.PoolingProto.PoolMethod pool = 1 [default = MAX];
  inline bool has_pool() const;
  inline void clear_pool();
  static const int kPoolFieldNumber = 1;
  inline ::singa::PoolingProto_PoolMethod pool() const;
  inline void set_pool(::singa::PoolingProto_PoolMethod value);

  // required uint32 kernel = 2;
  inline bool has_kernel() const;
  inline void clear_kernel();
  static const int kKernelFieldNumber = 2;
  inline ::google::protobuf::uint32 kernel() const;
  inline void set_kernel(::google::protobuf::uint32 value);

  // optional uint32 pad = 4 [default = 0];
  inline bool has_pad() const;
  inline void clear_pad();
  static const int kPadFieldNumber = 4;
  inline ::google::protobuf::uint32 pad() const;
  inline void set_pad(::google::protobuf::uint32 value);

  // optional uint32 stride = 3 [default = 1];
  inline bool has_stride() const;
  inline void clear_stride();
  static const int kStrideFieldNumber = 3;
  inline ::google::protobuf::uint32 stride() const;
  inline void set_stride(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:singa.PoolingProto)
 private:
  inline void set_has_pool();
  inline void clear_has_pool();
  inline void set_has_kernel();
  inline void clear_has_kernel();
  inline void set_has_pad();
  inline void clear_has_pad();
  inline void set_has_stride();
  inline void clear_has_stride();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int pool_;
  ::google::protobuf::uint32 kernel_;
  ::google::protobuf::uint32 pad_;
  ::google::protobuf::uint32 stride_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static PoolingProto* default_instance_;
};
// -------------------------------------------------------------------

class SliceProto : public ::google::protobuf::Message {
 public:
  SliceProto();
  virtual ~SliceProto();

  SliceProto(const SliceProto& from);

  inline SliceProto& operator=(const SliceProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SliceProto& default_instance();

  void Swap(SliceProto* other);

  // implements Message ----------------------------------------------

  SliceProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SliceProto& from);
  void MergeFrom(const SliceProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 slice_dimension = 1;
  inline bool has_slice_dimension() const;
  inline void clear_slice_dimension();
  static const int kSliceDimensionFieldNumber = 1;
  inline ::google::protobuf::int32 slice_dimension() const;
  inline void set_slice_dimension(::google::protobuf::int32 value);

  // optional int32 slice_num = 2;
  inline bool has_slice_num() const;
  inline void clear_slice_num();
  static const int kSliceNumFieldNumber = 2;
  inline ::google::protobuf::int32 slice_num() const;
  inline void set_slice_num(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:singa.SliceProto)
 private:
  inline void set_has_slice_dimension();
  inline void clear_has_slice_dimension();
  inline void set_has_slice_num();
  inline void clear_has_slice_num();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 slice_dimension_;
  ::google::protobuf::int32 slice_num_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static SliceProto* default_instance_;
};
// -------------------------------------------------------------------

class ReLUProto : public ::google::protobuf::Message {
 public:
  ReLUProto();
  virtual ~ReLUProto();

  ReLUProto(const ReLUProto& from);

  inline ReLUProto& operator=(const ReLUProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ReLUProto& default_instance();

  void Swap(ReLUProto* other);

  // implements Message ----------------------------------------------

  ReLUProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ReLUProto& from);
  void MergeFrom(const ReLUProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional float negative_slope = 1 [default = 0];
  inline bool has_negative_slope() const;
  inline void clear_negative_slope();
  static const int kNegativeSlopeFieldNumber = 1;
  inline float negative_slope() const;
  inline void set_negative_slope(float value);

  // @@protoc_insertion_point(class_scope:singa.ReLUProto)
 private:
  inline void set_has_negative_slope();
  inline void clear_has_negative_slope();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float negative_slope_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static ReLUProto* default_instance_;
};
// -------------------------------------------------------------------

class Record : public ::google::protobuf::Message {
 public:
  Record();
  virtual ~Record();

  Record(const Record& from);

  inline Record& operator=(const Record& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Record& default_instance();

  void Swap(Record* other);

  // implements Message ----------------------------------------------

  Record* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Record& from);
  void MergeFrom(const Record& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef Record_Type Type;
  static const Type kSingleLabelImage = Record_Type_kSingleLabelImage;
  static inline bool Type_IsValid(int value) {
    return Record_Type_IsValid(value);
  }
  static const Type Type_MIN =
    Record_Type_Type_MIN;
  static const Type Type_MAX =
    Record_Type_Type_MAX;
  static const int Type_ARRAYSIZE =
    Record_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Type_descriptor() {
    return Record_Type_descriptor();
  }
  static inline const ::std::string& Type_Name(Type value) {
    return Record_Type_Name(value);
  }
  static inline bool Type_Parse(const ::std::string& name,
      Type* value) {
    return Record_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .singa.Record.Type type = 1 [default = kSingleLabelImage];
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::singa::Record_Type type() const;
  inline void set_type(::singa::Record_Type value);

  // optional .singa.SingleLabelImageRecord image = 2;
  inline bool has_image() const;
  inline void clear_image();
  static const int kImageFieldNumber = 2;
  inline const ::singa::SingleLabelImageRecord& image() const;
  inline ::singa::SingleLabelImageRecord* mutable_image();
  inline ::singa::SingleLabelImageRecord* release_image();
  inline void set_allocated_image(::singa::SingleLabelImageRecord* image);

  // @@protoc_insertion_point(class_scope:singa.Record)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_image();
  inline void clear_has_image();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::singa::SingleLabelImageRecord* image_;
  int type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static Record* default_instance_;
};
// -------------------------------------------------------------------

class Datum : public ::google::protobuf::Message {
 public:
  Datum();
  virtual ~Datum();

  Datum(const Datum& from);

  inline Datum& operator=(const Datum& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Datum& default_instance();

  void Swap(Datum* other);

  // implements Message ----------------------------------------------

  Datum* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Datum& from);
  void MergeFrom(const Datum& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 channels = 1;
  inline bool has_channels() const;
  inline void clear_channels();
  static const int kChannelsFieldNumber = 1;
  inline ::google::protobuf::int32 channels() const;
  inline void set_channels(::google::protobuf::int32 value);

  // optional int32 height = 2;
  inline bool has_height() const;
  inline void clear_height();
  static const int kHeightFieldNumber = 2;
  inline ::google::protobuf::int32 height() const;
  inline void set_height(::google::protobuf::int32 value);

  // optional int32 width = 3;
  inline bool has_width() const;
  inline void clear_width();
  static const int kWidthFieldNumber = 3;
  inline ::google::protobuf::int32 width() const;
  inline void set_width(::google::protobuf::int32 value);

  // optional bytes data = 4;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 4;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // optional int32 label = 5;
  inline bool has_label() const;
  inline void clear_label();
  static const int kLabelFieldNumber = 5;
  inline ::google::protobuf::int32 label() const;
  inline void set_label(::google::protobuf::int32 value);

  // repeated float float_data = 6;
  inline int float_data_size() const;
  inline void clear_float_data();
  static const int kFloatDataFieldNumber = 6;
  inline float float_data(int index) const;
  inline void set_float_data(int index, float value);
  inline void add_float_data(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      float_data() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_float_data();

  // optional bool encoded = 7 [default = false];
  inline bool has_encoded() const;
  inline void clear_encoded();
  static const int kEncodedFieldNumber = 7;
  inline bool encoded() const;
  inline void set_encoded(bool value);

  // @@protoc_insertion_point(class_scope:singa.Datum)
 private:
  inline void set_has_channels();
  inline void clear_has_channels();
  inline void set_has_height();
  inline void clear_has_height();
  inline void set_has_width();
  inline void clear_has_width();
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_label();
  inline void clear_has_label();
  inline void set_has_encoded();
  inline void clear_has_encoded();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 channels_;
  ::google::protobuf::int32 height_;
  ::std::string* data_;
  ::google::protobuf::int32 width_;
  ::google::protobuf::int32 label_;
  ::google::protobuf::RepeatedField< float > float_data_;
  bool encoded_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static Datum* default_instance_;
};
// -------------------------------------------------------------------

class SingleLabelImageRecord : public ::google::protobuf::Message {
 public:
  SingleLabelImageRecord();
  virtual ~SingleLabelImageRecord();

  SingleLabelImageRecord(const SingleLabelImageRecord& from);

  inline SingleLabelImageRecord& operator=(const SingleLabelImageRecord& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SingleLabelImageRecord& default_instance();

  void Swap(SingleLabelImageRecord* other);

  // implements Message ----------------------------------------------

  SingleLabelImageRecord* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SingleLabelImageRecord& from);
  void MergeFrom(const SingleLabelImageRecord& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 shape = 1;
  inline int shape_size() const;
  inline void clear_shape();
  static const int kShapeFieldNumber = 1;
  inline ::google::protobuf::int32 shape(int index) const;
  inline void set_shape(int index, ::google::protobuf::int32 value);
  inline void add_shape(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      shape() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_shape();

  // optional int32 label = 2;
  inline bool has_label() const;
  inline void clear_label();
  static const int kLabelFieldNumber = 2;
  inline ::google::protobuf::int32 label() const;
  inline void set_label(::google::protobuf::int32 value);

  // optional bytes pixel = 3;
  inline bool has_pixel() const;
  inline void clear_pixel();
  static const int kPixelFieldNumber = 3;
  inline const ::std::string& pixel() const;
  inline void set_pixel(const ::std::string& value);
  inline void set_pixel(const char* value);
  inline void set_pixel(const void* value, size_t size);
  inline ::std::string* mutable_pixel();
  inline ::std::string* release_pixel();
  inline void set_allocated_pixel(::std::string* pixel);

  // repeated float data = 4;
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 4;
  inline float data(int index) const;
  inline void set_data(int index, float value);
  inline void add_data(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      data() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:singa.SingleLabelImageRecord)
 private:
  inline void set_has_label();
  inline void clear_has_label();
  inline void set_has_pixel();
  inline void clear_has_pixel();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > shape_;
  ::std::string* pixel_;
  ::google::protobuf::RepeatedField< float > data_;
  ::google::protobuf::int32 label_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static SingleLabelImageRecord* default_instance_;
};
// -------------------------------------------------------------------

class UpdaterProto : public ::google::protobuf::Message {
 public:
  UpdaterProto();
  virtual ~UpdaterProto();

  UpdaterProto(const UpdaterProto& from);

  inline UpdaterProto& operator=(const UpdaterProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UpdaterProto& default_instance();

  void Swap(UpdaterProto* other);

  // implements Message ----------------------------------------------

  UpdaterProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UpdaterProto& from);
  void MergeFrom(const UpdaterProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef UpdaterProto_ChangeProto ChangeProto;
  static const ChangeProto kFixed = UpdaterProto_ChangeProto_kFixed;
  static const ChangeProto kInverse_t = UpdaterProto_ChangeProto_kInverse_t;
  static const ChangeProto kInverse = UpdaterProto_ChangeProto_kInverse;
  static const ChangeProto kExponential = UpdaterProto_ChangeProto_kExponential;
  static const ChangeProto kLinear = UpdaterProto_ChangeProto_kLinear;
  static const ChangeProto kStep = UpdaterProto_ChangeProto_kStep;
  static const ChangeProto kFixedStep = UpdaterProto_ChangeProto_kFixedStep;
  static inline bool ChangeProto_IsValid(int value) {
    return UpdaterProto_ChangeProto_IsValid(value);
  }
  static const ChangeProto ChangeProto_MIN =
    UpdaterProto_ChangeProto_ChangeProto_MIN;
  static const ChangeProto ChangeProto_MAX =
    UpdaterProto_ChangeProto_ChangeProto_MAX;
  static const int ChangeProto_ARRAYSIZE =
    UpdaterProto_ChangeProto_ChangeProto_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  ChangeProto_descriptor() {
    return UpdaterProto_ChangeProto_descriptor();
  }
  static inline const ::std::string& ChangeProto_Name(ChangeProto value) {
    return UpdaterProto_ChangeProto_Name(value);
  }
  static inline bool ChangeProto_Parse(const ::std::string& name,
      ChangeProto* value) {
    return UpdaterProto_ChangeProto_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional float momentum = 4 [default = 0];
  inline bool has_momentum() const;
  inline void clear_momentum();
  static const int kMomentumFieldNumber = 4;
  inline float momentum() const;
  inline void set_momentum(float value);

  // optional float weight_decay = 5 [default = 0];
  inline bool has_weight_decay() const;
  inline void clear_weight_decay();
  static const int kWeightDecayFieldNumber = 5;
  inline float weight_decay() const;
  inline void set_weight_decay(float value);

  // optional float gamma = 6 [default = 1];
  inline bool has_gamma() const;
  inline void clear_gamma();
  static const int kGammaFieldNumber = 6;
  inline float gamma() const;
  inline void set_gamma(float value);

  // optional float pow = 7 [default = 0];
  inline bool has_pow() const;
  inline void clear_pow();
  static const int kPowFieldNumber = 7;
  inline float pow() const;
  inline void set_pow(float value);

  // optional float delta = 8 [default = 1e-07];
  inline bool has_delta() const;
  inline void clear_delta();
  static const int kDeltaFieldNumber = 8;
  inline float delta() const;
  inline void set_delta(float value);

  // optional float rho = 9 [default = 0.9];
  inline bool has_rho() const;
  inline void clear_rho();
  static const int kRhoFieldNumber = 9;
  inline float rho() const;
  inline void set_rho(float value);

  // optional float base_learning_rate = 12;
  inline bool has_base_learning_rate() const;
  inline void clear_base_learning_rate();
  static const int kBaseLearningRateFieldNumber = 12;
  inline float base_learning_rate() const;
  inline void set_base_learning_rate(float value);

  // optional float final_learning_rate = 13;
  inline bool has_final_learning_rate() const;
  inline void clear_final_learning_rate();
  static const int kFinalLearningRateFieldNumber = 13;
  inline float final_learning_rate() const;
  inline void set_final_learning_rate(float value);

  // optional int32 learning_rate_change_frequency = 14;
  inline bool has_learning_rate_change_frequency() const;
  inline void clear_learning_rate_change_frequency();
  static const int kLearningRateChangeFrequencyFieldNumber = 14;
  inline ::google::protobuf::int32 learning_rate_change_frequency() const;
  inline void set_learning_rate_change_frequency(::google::protobuf::int32 value);

  // optional .singa.UpdaterProto.ChangeProto learning_rate_change_method = 16 [default = kFixed];
  inline bool has_learning_rate_change_method() const;
  inline void clear_learning_rate_change_method();
  static const int kLearningRateChangeMethodFieldNumber = 16;
  inline ::singa::UpdaterProto_ChangeProto learning_rate_change_method() const;
  inline void set_learning_rate_change_method(::singa::UpdaterProto_ChangeProto value);

  // optional int32 sync_frequency = 17 [default = 1];
  inline bool has_sync_frequency() const;
  inline void clear_sync_frequency();
  static const int kSyncFrequencyFieldNumber = 17;
  inline ::google::protobuf::int32 sync_frequency() const;
  inline void set_sync_frequency(::google::protobuf::int32 value);

  // optional float moving_rate = 26 [default = 0];
  inline bool has_moving_rate() const;
  inline void clear_moving_rate();
  static const int kMovingRateFieldNumber = 26;
  inline float moving_rate() const;
  inline void set_moving_rate(float value);

  // optional string param_type = 27 [default = "Param"];
  inline bool has_param_type() const;
  inline void clear_param_type();
  static const int kParamTypeFieldNumber = 27;
  inline const ::std::string& param_type() const;
  inline void set_param_type(const ::std::string& value);
  inline void set_param_type(const char* value);
  inline void set_param_type(const char* value, size_t size);
  inline ::std::string* mutable_param_type();
  inline ::std::string* release_param_type();
  inline void set_allocated_param_type(::std::string* param_type);

  // repeated int32 step = 28;
  inline int step_size() const;
  inline void clear_step();
  static const int kStepFieldNumber = 28;
  inline ::google::protobuf::int32 step(int index) const;
  inline void set_step(int index, ::google::protobuf::int32 value);
  inline void add_step(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      step() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_step();

  // repeated float step_lr = 29;
  inline int step_lr_size() const;
  inline void clear_step_lr();
  static const int kStepLrFieldNumber = 29;
  inline float step_lr(int index) const;
  inline void set_step_lr(int index, float value);
  inline void add_step_lr(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      step_lr() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_step_lr();

  // @@protoc_insertion_point(class_scope:singa.UpdaterProto)
 private:
  inline void set_has_momentum();
  inline void clear_has_momentum();
  inline void set_has_weight_decay();
  inline void clear_has_weight_decay();
  inline void set_has_gamma();
  inline void clear_has_gamma();
  inline void set_has_pow();
  inline void clear_has_pow();
  inline void set_has_delta();
  inline void clear_has_delta();
  inline void set_has_rho();
  inline void clear_has_rho();
  inline void set_has_base_learning_rate();
  inline void clear_has_base_learning_rate();
  inline void set_has_final_learning_rate();
  inline void clear_has_final_learning_rate();
  inline void set_has_learning_rate_change_frequency();
  inline void clear_has_learning_rate_change_frequency();
  inline void set_has_learning_rate_change_method();
  inline void clear_has_learning_rate_change_method();
  inline void set_has_sync_frequency();
  inline void clear_has_sync_frequency();
  inline void set_has_moving_rate();
  inline void clear_has_moving_rate();
  inline void set_has_param_type();
  inline void clear_has_param_type();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float momentum_;
  float weight_decay_;
  float gamma_;
  float pow_;
  float delta_;
  float rho_;
  float base_learning_rate_;
  float final_learning_rate_;
  ::google::protobuf::int32 learning_rate_change_frequency_;
  int learning_rate_change_method_;
  ::google::protobuf::int32 sync_frequency_;
  float moving_rate_;
  ::std::string* param_type_;
  static ::std::string* _default_param_type_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > step_;
  ::google::protobuf::RepeatedField< float > step_lr_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(15 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static UpdaterProto* default_instance_;
};
// -------------------------------------------------------------------

class BlobProto : public ::google::protobuf::Message {
 public:
  BlobProto();
  virtual ~BlobProto();

  BlobProto(const BlobProto& from);

  inline BlobProto& operator=(const BlobProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlobProto& default_instance();

  void Swap(BlobProto* other);

  // implements Message ----------------------------------------------

  BlobProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlobProto& from);
  void MergeFrom(const BlobProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 num = 1 [default = 0];
  inline bool has_num() const;
  inline void clear_num();
  static const int kNumFieldNumber = 1;
  inline ::google::protobuf::int32 num() const;
  inline void set_num(::google::protobuf::int32 value);

  // optional int32 channels = 2 [default = 0];
  inline bool has_channels() const;
  inline void clear_channels();
  static const int kChannelsFieldNumber = 2;
  inline ::google::protobuf::int32 channels() const;
  inline void set_channels(::google::protobuf::int32 value);

  // optional int32 height = 3 [default = 0];
  inline bool has_height() const;
  inline void clear_height();
  static const int kHeightFieldNumber = 3;
  inline ::google::protobuf::int32 height() const;
  inline void set_height(::google::protobuf::int32 value);

  // optional int32 width = 4 [default = 0];
  inline bool has_width() const;
  inline void clear_width();
  static const int kWidthFieldNumber = 4;
  inline ::google::protobuf::int32 width() const;
  inline void set_width(::google::protobuf::int32 value);

  // repeated float data = 5 [packed = true];
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 5;
  inline float data(int index) const;
  inline void set_data(int index, float value);
  inline void add_data(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      data() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_data();

  // repeated float diff = 6 [packed = true];
  inline int diff_size() const;
  inline void clear_diff();
  static const int kDiffFieldNumber = 6;
  inline float diff(int index) const;
  inline void set_diff(int index, float value);
  inline void add_diff(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      diff() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_diff();

  // @@protoc_insertion_point(class_scope:singa.BlobProto)
 private:
  inline void set_has_num();
  inline void clear_has_num();
  inline void set_has_channels();
  inline void clear_has_channels();
  inline void set_has_height();
  inline void clear_has_height();
  inline void set_has_width();
  inline void clear_has_width();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 num_;
  ::google::protobuf::int32 channels_;
  ::google::protobuf::int32 height_;
  ::google::protobuf::int32 width_;
  ::google::protobuf::RepeatedField< float > data_;
  mutable int _data_cached_byte_size_;
  ::google::protobuf::RepeatedField< float > diff_;
  mutable int _diff_cached_byte_size_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  friend void  protobuf_AddDesc_model_2eproto();
  friend void protobuf_AssignDesc_model_2eproto();
  friend void protobuf_ShutdownFile_model_2eproto();

  void InitAsDefaultInstance();
  static BlobProto* default_instance_;
};
// ===================================================================


// ===================================================================

// ModelProto

// optional string name = 1;
inline bool ModelProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ModelProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ModelProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ModelProto::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& ModelProto::name() const {
  return *name_;
}
inline void ModelProto::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void ModelProto::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void ModelProto::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ModelProto::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* ModelProto::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ModelProto::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string train_folder = 2 [default = "train"];
inline bool ModelProto::has_train_folder() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ModelProto::set_has_train_folder() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ModelProto::clear_has_train_folder() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ModelProto::clear_train_folder() {
  if (train_folder_ != _default_train_folder_) {
    train_folder_->assign(*_default_train_folder_);
  }
  clear_has_train_folder();
}
inline const ::std::string& ModelProto::train_folder() const {
  return *train_folder_;
}
inline void ModelProto::set_train_folder(const ::std::string& value) {
  set_has_train_folder();
  if (train_folder_ == _default_train_folder_) {
    train_folder_ = new ::std::string;
  }
  train_folder_->assign(value);
}
inline void ModelProto::set_train_folder(const char* value) {
  set_has_train_folder();
  if (train_folder_ == _default_train_folder_) {
    train_folder_ = new ::std::string;
  }
  train_folder_->assign(value);
}
inline void ModelProto::set_train_folder(const char* value, size_t size) {
  set_has_train_folder();
  if (train_folder_ == _default_train_folder_) {
    train_folder_ = new ::std::string;
  }
  train_folder_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ModelProto::mutable_train_folder() {
  set_has_train_folder();
  if (train_folder_ == _default_train_folder_) {
    train_folder_ = new ::std::string(*_default_train_folder_);
  }
  return train_folder_;
}
inline ::std::string* ModelProto::release_train_folder() {
  clear_has_train_folder();
  if (train_folder_ == _default_train_folder_) {
    return NULL;
  } else {
    ::std::string* temp = train_folder_;
    train_folder_ = const_cast< ::std::string*>(_default_train_folder_);
    return temp;
  }
}
inline void ModelProto::set_allocated_train_folder(::std::string* train_folder) {
  if (train_folder_ != _default_train_folder_) {
    delete train_folder_;
  }
  if (train_folder) {
    set_has_train_folder();
    train_folder_ = train_folder;
  } else {
    clear_has_train_folder();
    train_folder_ = const_cast< ::std::string*>(_default_train_folder_);
  }
}

// optional string test_folder = 3 [default = "test"];
inline bool ModelProto::has_test_folder() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ModelProto::set_has_test_folder() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ModelProto::clear_has_test_folder() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ModelProto::clear_test_folder() {
  if (test_folder_ != _default_test_folder_) {
    test_folder_->assign(*_default_test_folder_);
  }
  clear_has_test_folder();
}
inline const ::std::string& ModelProto::test_folder() const {
  return *test_folder_;
}
inline void ModelProto::set_test_folder(const ::std::string& value) {
  set_has_test_folder();
  if (test_folder_ == _default_test_folder_) {
    test_folder_ = new ::std::string;
  }
  test_folder_->assign(value);
}
inline void ModelProto::set_test_folder(const char* value) {
  set_has_test_folder();
  if (test_folder_ == _default_test_folder_) {
    test_folder_ = new ::std::string;
  }
  test_folder_->assign(value);
}
inline void ModelProto::set_test_folder(const char* value, size_t size) {
  set_has_test_folder();
  if (test_folder_ == _default_test_folder_) {
    test_folder_ = new ::std::string;
  }
  test_folder_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ModelProto::mutable_test_folder() {
  set_has_test_folder();
  if (test_folder_ == _default_test_folder_) {
    test_folder_ = new ::std::string(*_default_test_folder_);
  }
  return test_folder_;
}
inline ::std::string* ModelProto::release_test_folder() {
  clear_has_test_folder();
  if (test_folder_ == _default_test_folder_) {
    return NULL;
  } else {
    ::std::string* temp = test_folder_;
    test_folder_ = const_cast< ::std::string*>(_default_test_folder_);
    return temp;
  }
}
inline void ModelProto::set_allocated_test_folder(::std::string* test_folder) {
  if (test_folder_ != _default_test_folder_) {
    delete test_folder_;
  }
  if (test_folder) {
    set_has_test_folder();
    test_folder_ = test_folder;
  } else {
    clear_has_test_folder();
    test_folder_ = const_cast< ::std::string*>(_default_test_folder_);
  }
}

// optional string validation_folder = 4 [default = "validation"];
inline bool ModelProto::has_validation_folder() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ModelProto::set_has_validation_folder() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ModelProto::clear_has_validation_folder() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ModelProto::clear_validation_folder() {
  if (validation_folder_ != _default_validation_folder_) {
    validation_folder_->assign(*_default_validation_folder_);
  }
  clear_has_validation_folder();
}
inline const ::std::string& ModelProto::validation_folder() const {
  return *validation_folder_;
}
inline void ModelProto::set_validation_folder(const ::std::string& value) {
  set_has_validation_folder();
  if (validation_folder_ == _default_validation_folder_) {
    validation_folder_ = new ::std::string;
  }
  validation_folder_->assign(value);
}
inline void ModelProto::set_validation_folder(const char* value) {
  set_has_validation_folder();
  if (validation_folder_ == _default_validation_folder_) {
    validation_folder_ = new ::std::string;
  }
  validation_folder_->assign(value);
}
inline void ModelProto::set_validation_folder(const char* value, size_t size) {
  set_has_validation_folder();
  if (validation_folder_ == _default_validation_folder_) {
    validation_folder_ = new ::std::string;
  }
  validation_folder_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ModelProto::mutable_validation_folder() {
  set_has_validation_folder();
  if (validation_folder_ == _default_validation_folder_) {
    validation_folder_ = new ::std::string(*_default_validation_folder_);
  }
  return validation_folder_;
}
inline ::std::string* ModelProto::release_validation_folder() {
  clear_has_validation_folder();
  if (validation_folder_ == _default_validation_folder_) {
    return NULL;
  } else {
    ::std::string* temp = validation_folder_;
    validation_folder_ = const_cast< ::std::string*>(_default_validation_folder_);
    return temp;
  }
}
inline void ModelProto::set_allocated_validation_folder(::std::string* validation_folder) {
  if (validation_folder_ != _default_validation_folder_) {
    delete validation_folder_;
  }
  if (validation_folder) {
    set_has_validation_folder();
    validation_folder_ = validation_folder;
  } else {
    clear_has_validation_folder();
    validation_folder_ = const_cast< ::std::string*>(_default_validation_folder_);
  }
}

// optional int32 display_after_steps = 6 [default = 0];
inline bool ModelProto::has_display_after_steps() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ModelProto::set_has_display_after_steps() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ModelProto::clear_has_display_after_steps() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ModelProto::clear_display_after_steps() {
  display_after_steps_ = 0;
  clear_has_display_after_steps();
}
inline ::google::protobuf::int32 ModelProto::display_after_steps() const {
  return display_after_steps_;
}
inline void ModelProto::set_display_after_steps(::google::protobuf::int32 value) {
  set_has_display_after_steps();
  display_after_steps_ = value;
}

// optional int32 display_frequency = 7 [default = 0];
inline bool ModelProto::has_display_frequency() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ModelProto::set_has_display_frequency() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ModelProto::clear_has_display_frequency() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ModelProto::clear_display_frequency() {
  display_frequency_ = 0;
  clear_has_display_frequency();
}
inline ::google::protobuf::int32 ModelProto::display_frequency() const {
  return display_frequency_;
}
inline void ModelProto::set_display_frequency(::google::protobuf::int32 value) {
  set_has_display_frequency();
  display_frequency_ = value;
}

// optional int32 validation_after_steps = 10 [default = 0];
inline bool ModelProto::has_validation_after_steps() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ModelProto::set_has_validation_after_steps() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ModelProto::clear_has_validation_after_steps() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ModelProto::clear_validation_after_steps() {
  validation_after_steps_ = 0;
  clear_has_validation_after_steps();
}
inline ::google::protobuf::int32 ModelProto::validation_after_steps() const {
  return validation_after_steps_;
}
inline void ModelProto::set_validation_after_steps(::google::protobuf::int32 value) {
  set_has_validation_after_steps();
  validation_after_steps_ = value;
}

// optional int32 validation_frequency = 11 [default = 0];
inline bool ModelProto::has_validation_frequency() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ModelProto::set_has_validation_frequency() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ModelProto::clear_has_validation_frequency() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ModelProto::clear_validation_frequency() {
  validation_frequency_ = 0;
  clear_has_validation_frequency();
}
inline ::google::protobuf::int32 ModelProto::validation_frequency() const {
  return validation_frequency_;
}
inline void ModelProto::set_validation_frequency(::google::protobuf::int32 value) {
  set_has_validation_frequency();
  validation_frequency_ = value;
}

// optional int32 test_after_steps = 13 [default = 0];
inline bool ModelProto::has_test_after_steps() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ModelProto::set_has_test_after_steps() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ModelProto::clear_has_test_after_steps() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ModelProto::clear_test_after_steps() {
  test_after_steps_ = 0;
  clear_has_test_after_steps();
}
inline ::google::protobuf::int32 ModelProto::test_after_steps() const {
  return test_after_steps_;
}
inline void ModelProto::set_test_after_steps(::google::protobuf::int32 value) {
  set_has_test_after_steps();
  test_after_steps_ = value;
}

// optional int32 test_frequency = 14 [default = 0];
inline bool ModelProto::has_test_frequency() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ModelProto::set_has_test_frequency() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ModelProto::clear_has_test_frequency() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ModelProto::clear_test_frequency() {
  test_frequency_ = 0;
  clear_has_test_frequency();
}
inline ::google::protobuf::int32 ModelProto::test_frequency() const {
  return test_frequency_;
}
inline void ModelProto::set_test_frequency(::google::protobuf::int32 value) {
  set_has_test_frequency();
  test_frequency_ = value;
}

// optional int32 checkpoint_after_steps = 15 [default = 0];
inline bool ModelProto::has_checkpoint_after_steps() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ModelProto::set_has_checkpoint_after_steps() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ModelProto::clear_has_checkpoint_after_steps() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ModelProto::clear_checkpoint_after_steps() {
  checkpoint_after_steps_ = 0;
  clear_has_checkpoint_after_steps();
}
inline ::google::protobuf::int32 ModelProto::checkpoint_after_steps() const {
  return checkpoint_after_steps_;
}
inline void ModelProto::set_checkpoint_after_steps(::google::protobuf::int32 value) {
  set_has_checkpoint_after_steps();
  checkpoint_after_steps_ = value;
}

// optional int32 checkpoint_frequency = 16 [default = 0];
inline bool ModelProto::has_checkpoint_frequency() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ModelProto::set_has_checkpoint_frequency() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ModelProto::clear_has_checkpoint_frequency() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ModelProto::clear_checkpoint_frequency() {
  checkpoint_frequency_ = 0;
  clear_has_checkpoint_frequency();
}
inline ::google::protobuf::int32 ModelProto::checkpoint_frequency() const {
  return checkpoint_frequency_;
}
inline void ModelProto::set_checkpoint_frequency(::google::protobuf::int32 value) {
  set_has_checkpoint_frequency();
  checkpoint_frequency_ = value;
}

// optional bool prefetch = 18 [default = true];
inline bool ModelProto::has_prefetch() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ModelProto::set_has_prefetch() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ModelProto::clear_has_prefetch() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ModelProto::clear_prefetch() {
  prefetch_ = true;
  clear_has_prefetch();
}
inline bool ModelProto::prefetch() const {
  return prefetch_;
}
inline void ModelProto::set_prefetch(bool value) {
  set_has_prefetch();
  prefetch_ = value;
}

// optional int32 train_steps = 20;
inline bool ModelProto::has_train_steps() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ModelProto::set_has_train_steps() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ModelProto::clear_has_train_steps() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ModelProto::clear_train_steps() {
  train_steps_ = 0;
  clear_has_train_steps();
}
inline ::google::protobuf::int32 ModelProto::train_steps() const {
  return train_steps_;
}
inline void ModelProto::set_train_steps(::google::protobuf::int32 value) {
  set_has_train_steps();
  train_steps_ = value;
}

// optional int32 validation_steps = 21;
inline bool ModelProto::has_validation_steps() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ModelProto::set_has_validation_steps() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ModelProto::clear_has_validation_steps() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ModelProto::clear_validation_steps() {
  validation_steps_ = 0;
  clear_has_validation_steps();
}
inline ::google::protobuf::int32 ModelProto::validation_steps() const {
  return validation_steps_;
}
inline void ModelProto::set_validation_steps(::google::protobuf::int32 value) {
  set_has_validation_steps();
  validation_steps_ = value;
}

// optional int32 test_steps = 22;
inline bool ModelProto::has_test_steps() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ModelProto::set_has_test_steps() {
  _has_bits_[0] |= 0x00008000u;
}
inline void ModelProto::clear_has_test_steps() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void ModelProto::clear_test_steps() {
  test_steps_ = 0;
  clear_has_test_steps();
}
inline ::google::protobuf::int32 ModelProto::test_steps() const {
  return test_steps_;
}
inline void ModelProto::set_test_steps(::google::protobuf::int32 value) {
  set_has_test_steps();
  test_steps_ = value;
}

// optional int32 step = 29 [default = 0];
inline bool ModelProto::has_step() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ModelProto::set_has_step() {
  _has_bits_[0] |= 0x00010000u;
}
inline void ModelProto::clear_has_step() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void ModelProto::clear_step() {
  step_ = 0;
  clear_has_step();
}
inline ::google::protobuf::int32 ModelProto::step() const {
  return step_;
}
inline void ModelProto::set_step(::google::protobuf::int32 value) {
  set_has_step();
  step_ = value;
}

// optional .singa.UpdaterProto updater = 31;
inline bool ModelProto::has_updater() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void ModelProto::set_has_updater() {
  _has_bits_[0] |= 0x00020000u;
}
inline void ModelProto::clear_has_updater() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void ModelProto::clear_updater() {
  if (updater_ != NULL) updater_->::singa::UpdaterProto::Clear();
  clear_has_updater();
}
inline const ::singa::UpdaterProto& ModelProto::updater() const {
  return updater_ != NULL ? *updater_ : *default_instance_->updater_;
}
inline ::singa::UpdaterProto* ModelProto::mutable_updater() {
  set_has_updater();
  if (updater_ == NULL) updater_ = new ::singa::UpdaterProto;
  return updater_;
}
inline ::singa::UpdaterProto* ModelProto::release_updater() {
  clear_has_updater();
  ::singa::UpdaterProto* temp = updater_;
  updater_ = NULL;
  return temp;
}
inline void ModelProto::set_allocated_updater(::singa::UpdaterProto* updater) {
  delete updater_;
  updater_ = updater;
  if (updater) {
    set_has_updater();
  } else {
    clear_has_updater();
  }
}

// optional .singa.ModelProto.GradCalcAlg alg = 32 [default = kBackPropagation];
inline bool ModelProto::has_alg() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void ModelProto::set_has_alg() {
  _has_bits_[0] |= 0x00040000u;
}
inline void ModelProto::clear_has_alg() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void ModelProto::clear_alg() {
  alg_ = 1;
  clear_has_alg();
}
inline ::singa::ModelProto_GradCalcAlg ModelProto::alg() const {
  return static_cast< ::singa::ModelProto_GradCalcAlg >(alg_);
}
inline void ModelProto::set_alg(::singa::ModelProto_GradCalcAlg value) {
  assert(::singa::ModelProto_GradCalcAlg_IsValid(value));
  set_has_alg();
  alg_ = value;
}

// optional bool hogwild = 33 [default = false];
inline bool ModelProto::has_hogwild() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void ModelProto::set_has_hogwild() {
  _has_bits_[0] |= 0x00080000u;
}
inline void ModelProto::clear_has_hogwild() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void ModelProto::clear_hogwild() {
  hogwild_ = false;
  clear_has_hogwild();
}
inline bool ModelProto::hogwild() const {
  return hogwild_;
}
inline void ModelProto::set_hogwild(bool value) {
  set_has_hogwild();
  hogwild_ = value;
}

// optional .singa.NetProto neuralnet = 40;
inline bool ModelProto::has_neuralnet() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void ModelProto::set_has_neuralnet() {
  _has_bits_[0] |= 0x00100000u;
}
inline void ModelProto::clear_has_neuralnet() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void ModelProto::clear_neuralnet() {
  if (neuralnet_ != NULL) neuralnet_->::singa::NetProto::Clear();
  clear_has_neuralnet();
}
inline const ::singa::NetProto& ModelProto::neuralnet() const {
  return neuralnet_ != NULL ? *neuralnet_ : *default_instance_->neuralnet_;
}
inline ::singa::NetProto* ModelProto::mutable_neuralnet() {
  set_has_neuralnet();
  if (neuralnet_ == NULL) neuralnet_ = new ::singa::NetProto;
  return neuralnet_;
}
inline ::singa::NetProto* ModelProto::release_neuralnet() {
  clear_has_neuralnet();
  ::singa::NetProto* temp = neuralnet_;
  neuralnet_ = NULL;
  return temp;
}
inline void ModelProto::set_allocated_neuralnet(::singa::NetProto* neuralnet) {
  delete neuralnet_;
  neuralnet_ = neuralnet;
  if (neuralnet) {
    set_has_neuralnet();
  } else {
    clear_has_neuralnet();
  }
}

// optional bool debug = 41 [default = false];
inline bool ModelProto::has_debug() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void ModelProto::set_has_debug() {
  _has_bits_[0] |= 0x00200000u;
}
inline void ModelProto::clear_has_debug() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void ModelProto::clear_debug() {
  debug_ = false;
  clear_has_debug();
}
inline bool ModelProto::debug() const {
  return debug_;
}
inline void ModelProto::set_debug(bool value) {
  set_has_debug();
  debug_ = value;
}

// optional int32 warmup_steps = 50 [default = 0];
inline bool ModelProto::has_warmup_steps() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void ModelProto::set_has_warmup_steps() {
  _has_bits_[0] |= 0x00400000u;
}
inline void ModelProto::clear_has_warmup_steps() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void ModelProto::clear_warmup_steps() {
  warmup_steps_ = 0;
  clear_has_warmup_steps();
}
inline ::google::protobuf::int32 ModelProto::warmup_steps() const {
  return warmup_steps_;
}
inline void ModelProto::set_warmup_steps(::google::protobuf::int32 value) {
  set_has_warmup_steps();
  warmup_steps_ = value;
}

// -------------------------------------------------------------------

// NetProto

// repeated .singa.LayerProto layer = 1;
inline int NetProto::layer_size() const {
  return layer_.size();
}
inline void NetProto::clear_layer() {
  layer_.Clear();
}
inline const ::singa::LayerProto& NetProto::layer(int index) const {
  return layer_.Get(index);
}
inline ::singa::LayerProto* NetProto::mutable_layer(int index) {
  return layer_.Mutable(index);
}
inline ::singa::LayerProto* NetProto::add_layer() {
  return layer_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >&
NetProto::layer() const {
  return layer_;
}
inline ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >*
NetProto::mutable_layer() {
  return &layer_;
}

// optional .singa.PartitionType partition_type = 3 [default = kNone];
inline bool NetProto::has_partition_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NetProto::set_has_partition_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NetProto::clear_has_partition_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NetProto::clear_partition_type() {
  partition_type_ = 2;
  clear_has_partition_type();
}
inline ::singa::PartitionType NetProto::partition_type() const {
  return static_cast< ::singa::PartitionType >(partition_type_);
}
inline void NetProto::set_partition_type(::singa::PartitionType value) {
  assert(::singa::PartitionType_IsValid(value));
  set_has_partition_type();
  partition_type_ = value;
}

// -------------------------------------------------------------------

// ParamProto

// optional string name = 1;
inline bool ParamProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ParamProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ParamProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ParamProto::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& ParamProto::name() const {
  return *name_;
}
inline void ParamProto::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void ParamProto::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void ParamProto::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ParamProto::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* ParamProto::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ParamProto::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 id = 2;
inline bool ParamProto::has_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ParamProto::set_has_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ParamProto::clear_has_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ParamProto::clear_id() {
  id_ = 0;
  clear_has_id();
}
inline ::google::protobuf::int32 ParamProto::id() const {
  return id_;
}
inline void ParamProto::set_id(::google::protobuf::int32 value) {
  set_has_id();
  id_ = value;
}

// repeated int32 shape = 3;
inline int ParamProto::shape_size() const {
  return shape_.size();
}
inline void ParamProto::clear_shape() {
  shape_.Clear();
}
inline ::google::protobuf::int32 ParamProto::shape(int index) const {
  return shape_.Get(index);
}
inline void ParamProto::set_shape(int index, ::google::protobuf::int32 value) {
  shape_.Set(index, value);
}
inline void ParamProto::add_shape(::google::protobuf::int32 value) {
  shape_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ParamProto::shape() const {
  return shape_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ParamProto::mutable_shape() {
  return &shape_;
}

// optional int32 split_threshold = 4 [default = 5000000];
inline bool ParamProto::has_split_threshold() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ParamProto::set_has_split_threshold() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ParamProto::clear_has_split_threshold() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ParamProto::clear_split_threshold() {
  split_threshold_ = 5000000;
  clear_has_split_threshold();
}
inline ::google::protobuf::int32 ParamProto::split_threshold() const {
  return split_threshold_;
}
inline void ParamProto::set_split_threshold(::google::protobuf::int32 value) {
  set_has_split_threshold();
  split_threshold_ = value;
}

// optional int32 partition_dim = 5 [default = -1];
inline bool ParamProto::has_partition_dim() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ParamProto::set_has_partition_dim() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ParamProto::clear_has_partition_dim() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ParamProto::clear_partition_dim() {
  partition_dim_ = -1;
  clear_has_partition_dim();
}
inline ::google::protobuf::int32 ParamProto::partition_dim() const {
  return partition_dim_;
}
inline void ParamProto::set_partition_dim(::google::protobuf::int32 value) {
  set_has_partition_dim();
  partition_dim_ = value;
}

// optional int32 owner = 6;
inline bool ParamProto::has_owner() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ParamProto::set_has_owner() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ParamProto::clear_has_owner() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ParamProto::clear_owner() {
  owner_ = 0;
  clear_has_owner();
}
inline ::google::protobuf::int32 ParamProto::owner() const {
  return owner_;
}
inline void ParamProto::set_owner(::google::protobuf::int32 value) {
  set_has_owner();
  owner_ = value;
}

// optional .singa.ParamProto.InitMethod init_method = 7 [default = kConstant];
inline bool ParamProto::has_init_method() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ParamProto::set_has_init_method() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ParamProto::clear_has_init_method() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ParamProto::clear_init_method() {
  init_method_ = 0;
  clear_has_init_method();
}
inline ::singa::ParamProto_InitMethod ParamProto::init_method() const {
  return static_cast< ::singa::ParamProto_InitMethod >(init_method_);
}
inline void ParamProto::set_init_method(::singa::ParamProto_InitMethod value) {
  assert(::singa::ParamProto_InitMethod_IsValid(value));
  set_has_init_method();
  init_method_ = value;
}

// optional float value = 8 [default = 1];
inline bool ParamProto::has_value() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ParamProto::set_has_value() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ParamProto::clear_has_value() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ParamProto::clear_value() {
  value_ = 1;
  clear_has_value();
}
inline float ParamProto::value() const {
  return value_;
}
inline void ParamProto::set_value(float value) {
  set_has_value();
  value_ = value;
}

// optional float low = 9 [default = -1];
inline bool ParamProto::has_low() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ParamProto::set_has_low() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ParamProto::clear_has_low() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ParamProto::clear_low() {
  low_ = -1;
  clear_has_low();
}
inline float ParamProto::low() const {
  return low_;
}
inline void ParamProto::set_low(float value) {
  set_has_low();
  low_ = value;
}

// optional float high = 10 [default = 1];
inline bool ParamProto::has_high() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ParamProto::set_has_high() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ParamProto::clear_has_high() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ParamProto::clear_high() {
  high_ = 1;
  clear_has_high();
}
inline float ParamProto::high() const {
  return high_;
}
inline void ParamProto::set_high(float value) {
  set_has_high();
  high_ = value;
}

// optional float mean = 11 [default = 0];
inline bool ParamProto::has_mean() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ParamProto::set_has_mean() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ParamProto::clear_has_mean() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ParamProto::clear_mean() {
  mean_ = 0;
  clear_has_mean();
}
inline float ParamProto::mean() const {
  return mean_;
}
inline void ParamProto::set_mean(float value) {
  set_has_mean();
  mean_ = value;
}

// optional float std = 12 [default = 1];
inline bool ParamProto::has_std() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ParamProto::set_has_std() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ParamProto::clear_has_std() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ParamProto::clear_std() {
  std_ = 1;
  clear_has_std();
}
inline float ParamProto::std() const {
  return std_;
}
inline void ParamProto::set_std(float value) {
  set_has_std();
  std_ = value;
}

// optional float learning_rate_multiplier = 13 [default = 1];
inline bool ParamProto::has_learning_rate_multiplier() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ParamProto::set_has_learning_rate_multiplier() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ParamProto::clear_has_learning_rate_multiplier() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ParamProto::clear_learning_rate_multiplier() {
  learning_rate_multiplier_ = 1;
  clear_has_learning_rate_multiplier();
}
inline float ParamProto::learning_rate_multiplier() const {
  return learning_rate_multiplier_;
}
inline void ParamProto::set_learning_rate_multiplier(float value) {
  set_has_learning_rate_multiplier();
  learning_rate_multiplier_ = value;
}

// optional float weight_decay_multiplier = 14 [default = 1];
inline bool ParamProto::has_weight_decay_multiplier() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ParamProto::set_has_weight_decay_multiplier() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ParamProto::clear_has_weight_decay_multiplier() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ParamProto::clear_weight_decay_multiplier() {
  weight_decay_multiplier_ = 1;
  clear_has_weight_decay_multiplier();
}
inline float ParamProto::weight_decay_multiplier() const {
  return weight_decay_multiplier_;
}
inline void ParamProto::set_weight_decay_multiplier(float value) {
  set_has_weight_decay_multiplier();
  weight_decay_multiplier_ = value;
}

// -------------------------------------------------------------------

// BlobProtos

// repeated .singa.BlobProto blobs = 1;
inline int BlobProtos::blobs_size() const {
  return blobs_.size();
}
inline void BlobProtos::clear_blobs() {
  blobs_.Clear();
}
inline const ::singa::BlobProto& BlobProtos::blobs(int index) const {
  return blobs_.Get(index);
}
inline ::singa::BlobProto* BlobProtos::mutable_blobs(int index) {
  return blobs_.Mutable(index);
}
inline ::singa::BlobProto* BlobProtos::add_blobs() {
  return blobs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::singa::BlobProto >&
BlobProtos::blobs() const {
  return blobs_;
}
inline ::google::protobuf::RepeatedPtrField< ::singa::BlobProto >*
BlobProtos::mutable_blobs() {
  return &blobs_;
}

// repeated int32 ids = 2;
inline int BlobProtos::ids_size() const {
  return ids_.size();
}
inline void BlobProtos::clear_ids() {
  ids_.Clear();
}
inline ::google::protobuf::int32 BlobProtos::ids(int index) const {
  return ids_.Get(index);
}
inline void BlobProtos::set_ids(int index, ::google::protobuf::int32 value) {
  ids_.Set(index, value);
}
inline void BlobProtos::add_ids(::google::protobuf::int32 value) {
  ids_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
BlobProtos::ids() const {
  return ids_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
BlobProtos::mutable_ids() {
  return &ids_;
}

// repeated string names = 3;
inline int BlobProtos::names_size() const {
  return names_.size();
}
inline void BlobProtos::clear_names() {
  names_.Clear();
}
inline const ::std::string& BlobProtos::names(int index) const {
  return names_.Get(index);
}
inline ::std::string* BlobProtos::mutable_names(int index) {
  return names_.Mutable(index);
}
inline void BlobProtos::set_names(int index, const ::std::string& value) {
  names_.Mutable(index)->assign(value);
}
inline void BlobProtos::set_names(int index, const char* value) {
  names_.Mutable(index)->assign(value);
}
inline void BlobProtos::set_names(int index, const char* value, size_t size) {
  names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BlobProtos::add_names() {
  return names_.Add();
}
inline void BlobProtos::add_names(const ::std::string& value) {
  names_.Add()->assign(value);
}
inline void BlobProtos::add_names(const char* value) {
  names_.Add()->assign(value);
}
inline void BlobProtos::add_names(const char* value, size_t size) {
  names_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
BlobProtos::names() const {
  return names_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
BlobProtos::mutable_names() {
  return &names_;
}

// -------------------------------------------------------------------

// LayerProto

// optional string name = 1;
inline bool LayerProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LayerProto::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LayerProto::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LayerProto::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& LayerProto::name() const {
  return *name_;
}
inline void LayerProto::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void LayerProto::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void LayerProto::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerProto::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* LayerProto::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LayerProto::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string type = 2;
inline bool LayerProto::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LayerProto::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LayerProto::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LayerProto::clear_type() {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    type_->clear();
  }
  clear_has_type();
}
inline const ::std::string& LayerProto::type() const {
  return *type_;
}
inline void LayerProto::set_type(const ::std::string& value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void LayerProto::set_type(const char* value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void LayerProto::set_type(const char* value, size_t size) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerProto::mutable_type() {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  return type_;
}
inline ::std::string* LayerProto::release_type() {
  clear_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = type_;
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LayerProto::set_allocated_type(::std::string* type) {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    delete type_;
  }
  if (type) {
    set_has_type();
    type_ = type;
  } else {
    clear_has_type();
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated string srclayers = 3;
inline int LayerProto::srclayers_size() const {
  return srclayers_.size();
}
inline void LayerProto::clear_srclayers() {
  srclayers_.Clear();
}
inline const ::std::string& LayerProto::srclayers(int index) const {
  return srclayers_.Get(index);
}
inline ::std::string* LayerProto::mutable_srclayers(int index) {
  return srclayers_.Mutable(index);
}
inline void LayerProto::set_srclayers(int index, const ::std::string& value) {
  srclayers_.Mutable(index)->assign(value);
}
inline void LayerProto::set_srclayers(int index, const char* value) {
  srclayers_.Mutable(index)->assign(value);
}
inline void LayerProto::set_srclayers(int index, const char* value, size_t size) {
  srclayers_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerProto::add_srclayers() {
  return srclayers_.Add();
}
inline void LayerProto::add_srclayers(const ::std::string& value) {
  srclayers_.Add()->assign(value);
}
inline void LayerProto::add_srclayers(const char* value) {
  srclayers_.Add()->assign(value);
}
inline void LayerProto::add_srclayers(const char* value, size_t size) {
  srclayers_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerProto::srclayers() const {
  return srclayers_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerProto::mutable_srclayers() {
  return &srclayers_;
}

// optional int32 locationid = 4 [default = 0];
inline bool LayerProto::has_locationid() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LayerProto::set_has_locationid() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LayerProto::clear_has_locationid() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LayerProto::clear_locationid() {
  locationid_ = 0;
  clear_has_locationid();
}
inline ::google::protobuf::int32 LayerProto::locationid() const {
  return locationid_;
}
inline void LayerProto::set_locationid(::google::protobuf::int32 value) {
  set_has_locationid();
  locationid_ = value;
}

// optional int32 partitionid = 5 [default = 0];
inline bool LayerProto::has_partitionid() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LayerProto::set_has_partitionid() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LayerProto::clear_has_partitionid() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LayerProto::clear_partitionid() {
  partitionid_ = 0;
  clear_has_partitionid();
}
inline ::google::protobuf::int32 LayerProto::partitionid() const {
  return partitionid_;
}
inline void LayerProto::set_partitionid(::google::protobuf::int32 value) {
  set_has_partitionid();
  partitionid_ = value;
}

// optional .singa.PartitionType partition_type = 6;
inline bool LayerProto::has_partition_type() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void LayerProto::set_has_partition_type() {
  _has_bits_[0] |= 0x00000020u;
}
inline void LayerProto::clear_has_partition_type() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void LayerProto::clear_partition_type() {
  partition_type_ = 0;
  clear_has_partition_type();
}
inline ::singa::PartitionType LayerProto::partition_type() const {
  return static_cast< ::singa::PartitionType >(partition_type_);
}
inline void LayerProto::set_partition_type(::singa::PartitionType value) {
  assert(::singa::PartitionType_IsValid(value));
  set_has_partition_type();
  partition_type_ = value;
}

// optional string datablob = 7;
inline bool LayerProto::has_datablob() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void LayerProto::set_has_datablob() {
  _has_bits_[0] |= 0x00000040u;
}
inline void LayerProto::clear_has_datablob() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void LayerProto::clear_datablob() {
  if (datablob_ != &::google::protobuf::internal::kEmptyString) {
    datablob_->clear();
  }
  clear_has_datablob();
}
inline const ::std::string& LayerProto::datablob() const {
  return *datablob_;
}
inline void LayerProto::set_datablob(const ::std::string& value) {
  set_has_datablob();
  if (datablob_ == &::google::protobuf::internal::kEmptyString) {
    datablob_ = new ::std::string;
  }
  datablob_->assign(value);
}
inline void LayerProto::set_datablob(const char* value) {
  set_has_datablob();
  if (datablob_ == &::google::protobuf::internal::kEmptyString) {
    datablob_ = new ::std::string;
  }
  datablob_->assign(value);
}
inline void LayerProto::set_datablob(const char* value, size_t size) {
  set_has_datablob();
  if (datablob_ == &::google::protobuf::internal::kEmptyString) {
    datablob_ = new ::std::string;
  }
  datablob_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerProto::mutable_datablob() {
  set_has_datablob();
  if (datablob_ == &::google::protobuf::internal::kEmptyString) {
    datablob_ = new ::std::string;
  }
  return datablob_;
}
inline ::std::string* LayerProto::release_datablob() {
  clear_has_datablob();
  if (datablob_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = datablob_;
    datablob_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LayerProto::set_allocated_datablob(::std::string* datablob) {
  if (datablob_ != &::google::protobuf::internal::kEmptyString) {
    delete datablob_;
  }
  if (datablob) {
    set_has_datablob();
    datablob_ = datablob;
  } else {
    clear_has_datablob();
    datablob_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated string share_ary = 11;
inline int LayerProto::share_ary_size() const {
  return share_ary_.size();
}
inline void LayerProto::clear_share_ary() {
  share_ary_.Clear();
}
inline const ::std::string& LayerProto::share_ary(int index) const {
  return share_ary_.Get(index);
}
inline ::std::string* LayerProto::mutable_share_ary(int index) {
  return share_ary_.Mutable(index);
}
inline void LayerProto::set_share_ary(int index, const ::std::string& value) {
  share_ary_.Mutable(index)->assign(value);
}
inline void LayerProto::set_share_ary(int index, const char* value) {
  share_ary_.Mutable(index)->assign(value);
}
inline void LayerProto::set_share_ary(int index, const char* value, size_t size) {
  share_ary_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerProto::add_share_ary() {
  return share_ary_.Add();
}
inline void LayerProto::add_share_ary(const ::std::string& value) {
  share_ary_.Add()->assign(value);
}
inline void LayerProto::add_share_ary(const char* value) {
  share_ary_.Add()->assign(value);
}
inline void LayerProto::add_share_ary(const char* value, size_t size) {
  share_ary_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerProto::share_ary() const {
  return share_ary_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerProto::mutable_share_ary() {
  return &share_ary_;
}

// repeated .singa.ParamProto param = 12;
inline int LayerProto::param_size() const {
  return param_.size();
}
inline void LayerProto::clear_param() {
  param_.Clear();
}
inline const ::singa::ParamProto& LayerProto::param(int index) const {
  return param_.Get(index);
}
inline ::singa::ParamProto* LayerProto::mutable_param(int index) {
  return param_.Mutable(index);
}
inline ::singa::ParamProto* LayerProto::add_param() {
  return param_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::singa::ParamProto >&
LayerProto::param() const {
  return param_;
}
inline ::google::protobuf::RepeatedPtrField< ::singa::ParamProto >*
LayerProto::mutable_param() {
  return &param_;
}

// repeated string share_param = 13;
inline int LayerProto::share_param_size() const {
  return share_param_.size();
}
inline void LayerProto::clear_share_param() {
  share_param_.Clear();
}
inline const ::std::string& LayerProto::share_param(int index) const {
  return share_param_.Get(index);
}
inline ::std::string* LayerProto::mutable_share_param(int index) {
  return share_param_.Mutable(index);
}
inline void LayerProto::set_share_param(int index, const ::std::string& value) {
  share_param_.Mutable(index)->assign(value);
}
inline void LayerProto::set_share_param(int index, const char* value) {
  share_param_.Mutable(index)->assign(value);
}
inline void LayerProto::set_share_param(int index, const char* value, size_t size) {
  share_param_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerProto::add_share_param() {
  return share_param_.Add();
}
inline void LayerProto::add_share_param(const ::std::string& value) {
  share_param_.Add()->assign(value);
}
inline void LayerProto::add_share_param(const char* value) {
  share_param_.Add()->assign(value);
}
inline void LayerProto::add_share_param(const char* value, size_t size) {
  share_param_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerProto::share_param() const {
  return share_param_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerProto::mutable_share_param() {
  return &share_param_;
}

// repeated .singa.Phase exclude = 20;
inline int LayerProto::exclude_size() const {
  return exclude_.size();
}
inline void LayerProto::clear_exclude() {
  exclude_.Clear();
}
inline ::singa::Phase LayerProto::exclude(int index) const {
  return static_cast< ::singa::Phase >(exclude_.Get(index));
}
inline void LayerProto::set_exclude(int index, ::singa::Phase value) {
  assert(::singa::Phase_IsValid(value));
  exclude_.Set(index, value);
}
inline void LayerProto::add_exclude(::singa::Phase value) {
  assert(::singa::Phase_IsValid(value));
  exclude_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
LayerProto::exclude() const {
  return exclude_;
}
inline ::google::protobuf::RepeatedField<int>*
LayerProto::mutable_exclude() {
  return &exclude_;
}

// optional .singa.ConvolutionProto convolution_param = 21;
inline bool LayerProto::has_convolution_param() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void LayerProto::set_has_convolution_param() {
  _has_bits_[0] |= 0x00000800u;
}
inline void LayerProto::clear_has_convolution_param() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void LayerProto::clear_convolution_param() {
  if (convolution_param_ != NULL) convolution_param_->::singa::ConvolutionProto::Clear();
  clear_has_convolution_param();
}
inline const ::singa::ConvolutionProto& LayerProto::convolution_param() const {
  return convolution_param_ != NULL ? *convolution_param_ : *default_instance_->convolution_param_;
}
inline ::singa::ConvolutionProto* LayerProto::mutable_convolution_param() {
  set_has_convolution_param();
  if (convolution_param_ == NULL) convolution_param_ = new ::singa::ConvolutionProto;
  return convolution_param_;
}
inline ::singa::ConvolutionProto* LayerProto::release_convolution_param() {
  clear_has_convolution_param();
  ::singa::ConvolutionProto* temp = convolution_param_;
  convolution_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_convolution_param(::singa::ConvolutionProto* convolution_param) {
  delete convolution_param_;
  convolution_param_ = convolution_param;
  if (convolution_param) {
    set_has_convolution_param();
  } else {
    clear_has_convolution_param();
  }
}

// optional .singa.ConcateProto concate_param = 31;
inline bool LayerProto::has_concate_param() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void LayerProto::set_has_concate_param() {
  _has_bits_[0] |= 0x00001000u;
}
inline void LayerProto::clear_has_concate_param() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void LayerProto::clear_concate_param() {
  if (concate_param_ != NULL) concate_param_->::singa::ConcateProto::Clear();
  clear_has_concate_param();
}
inline const ::singa::ConcateProto& LayerProto::concate_param() const {
  return concate_param_ != NULL ? *concate_param_ : *default_instance_->concate_param_;
}
inline ::singa::ConcateProto* LayerProto::mutable_concate_param() {
  set_has_concate_param();
  if (concate_param_ == NULL) concate_param_ = new ::singa::ConcateProto;
  return concate_param_;
}
inline ::singa::ConcateProto* LayerProto::release_concate_param() {
  clear_has_concate_param();
  ::singa::ConcateProto* temp = concate_param_;
  concate_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_concate_param(::singa::ConcateProto* concate_param) {
  delete concate_param_;
  concate_param_ = concate_param;
  if (concate_param) {
    set_has_concate_param();
  } else {
    clear_has_concate_param();
  }
}

// optional .singa.DataProto data_param = 22;
inline bool LayerProto::has_data_param() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void LayerProto::set_has_data_param() {
  _has_bits_[0] |= 0x00002000u;
}
inline void LayerProto::clear_has_data_param() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void LayerProto::clear_data_param() {
  if (data_param_ != NULL) data_param_->::singa::DataProto::Clear();
  clear_has_data_param();
}
inline const ::singa::DataProto& LayerProto::data_param() const {
  return data_param_ != NULL ? *data_param_ : *default_instance_->data_param_;
}
inline ::singa::DataProto* LayerProto::mutable_data_param() {
  set_has_data_param();
  if (data_param_ == NULL) data_param_ = new ::singa::DataProto;
  return data_param_;
}
inline ::singa::DataProto* LayerProto::release_data_param() {
  clear_has_data_param();
  ::singa::DataProto* temp = data_param_;
  data_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_data_param(::singa::DataProto* data_param) {
  delete data_param_;
  data_param_ = data_param;
  if (data_param) {
    set_has_data_param();
  } else {
    clear_has_data_param();
  }
}

// optional .singa.DropoutProto dropout_param = 23;
inline bool LayerProto::has_dropout_param() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void LayerProto::set_has_dropout_param() {
  _has_bits_[0] |= 0x00004000u;
}
inline void LayerProto::clear_has_dropout_param() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void LayerProto::clear_dropout_param() {
  if (dropout_param_ != NULL) dropout_param_->::singa::DropoutProto::Clear();
  clear_has_dropout_param();
}
inline const ::singa::DropoutProto& LayerProto::dropout_param() const {
  return dropout_param_ != NULL ? *dropout_param_ : *default_instance_->dropout_param_;
}
inline ::singa::DropoutProto* LayerProto::mutable_dropout_param() {
  set_has_dropout_param();
  if (dropout_param_ == NULL) dropout_param_ = new ::singa::DropoutProto;
  return dropout_param_;
}
inline ::singa::DropoutProto* LayerProto::release_dropout_param() {
  clear_has_dropout_param();
  ::singa::DropoutProto* temp = dropout_param_;
  dropout_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_dropout_param(::singa::DropoutProto* dropout_param) {
  delete dropout_param_;
  dropout_param_ = dropout_param;
  if (dropout_param) {
    set_has_dropout_param();
  } else {
    clear_has_dropout_param();
  }
}

// optional .singa.InnerProductProto inner_product_param = 24;
inline bool LayerProto::has_inner_product_param() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void LayerProto::set_has_inner_product_param() {
  _has_bits_[0] |= 0x00008000u;
}
inline void LayerProto::clear_has_inner_product_param() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void LayerProto::clear_inner_product_param() {
  if (inner_product_param_ != NULL) inner_product_param_->::singa::InnerProductProto::Clear();
  clear_has_inner_product_param();
}
inline const ::singa::InnerProductProto& LayerProto::inner_product_param() const {
  return inner_product_param_ != NULL ? *inner_product_param_ : *default_instance_->inner_product_param_;
}
inline ::singa::InnerProductProto* LayerProto::mutable_inner_product_param() {
  set_has_inner_product_param();
  if (inner_product_param_ == NULL) inner_product_param_ = new ::singa::InnerProductProto;
  return inner_product_param_;
}
inline ::singa::InnerProductProto* LayerProto::release_inner_product_param() {
  clear_has_inner_product_param();
  ::singa::InnerProductProto* temp = inner_product_param_;
  inner_product_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_inner_product_param(::singa::InnerProductProto* inner_product_param) {
  delete inner_product_param_;
  inner_product_param_ = inner_product_param;
  if (inner_product_param) {
    set_has_inner_product_param();
  } else {
    clear_has_inner_product_param();
  }
}

// optional .singa.LRNProto lrn_param = 25;
inline bool LayerProto::has_lrn_param() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void LayerProto::set_has_lrn_param() {
  _has_bits_[0] |= 0x00010000u;
}
inline void LayerProto::clear_has_lrn_param() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void LayerProto::clear_lrn_param() {
  if (lrn_param_ != NULL) lrn_param_->::singa::LRNProto::Clear();
  clear_has_lrn_param();
}
inline const ::singa::LRNProto& LayerProto::lrn_param() const {
  return lrn_param_ != NULL ? *lrn_param_ : *default_instance_->lrn_param_;
}
inline ::singa::LRNProto* LayerProto::mutable_lrn_param() {
  set_has_lrn_param();
  if (lrn_param_ == NULL) lrn_param_ = new ::singa::LRNProto;
  return lrn_param_;
}
inline ::singa::LRNProto* LayerProto::release_lrn_param() {
  clear_has_lrn_param();
  ::singa::LRNProto* temp = lrn_param_;
  lrn_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_lrn_param(::singa::LRNProto* lrn_param) {
  delete lrn_param_;
  lrn_param_ = lrn_param;
  if (lrn_param) {
    set_has_lrn_param();
  } else {
    clear_has_lrn_param();
  }
}

// optional .singa.MnistProto mnist_param = 26;
inline bool LayerProto::has_mnist_param() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void LayerProto::set_has_mnist_param() {
  _has_bits_[0] |= 0x00020000u;
}
inline void LayerProto::clear_has_mnist_param() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void LayerProto::clear_mnist_param() {
  if (mnist_param_ != NULL) mnist_param_->::singa::MnistProto::Clear();
  clear_has_mnist_param();
}
inline const ::singa::MnistProto& LayerProto::mnist_param() const {
  return mnist_param_ != NULL ? *mnist_param_ : *default_instance_->mnist_param_;
}
inline ::singa::MnistProto* LayerProto::mutable_mnist_param() {
  set_has_mnist_param();
  if (mnist_param_ == NULL) mnist_param_ = new ::singa::MnistProto;
  return mnist_param_;
}
inline ::singa::MnistProto* LayerProto::release_mnist_param() {
  clear_has_mnist_param();
  ::singa::MnistProto* temp = mnist_param_;
  mnist_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_mnist_param(::singa::MnistProto* mnist_param) {
  delete mnist_param_;
  mnist_param_ = mnist_param;
  if (mnist_param) {
    set_has_mnist_param();
  } else {
    clear_has_mnist_param();
  }
}

// optional .singa.PoolingProto pooling_param = 27;
inline bool LayerProto::has_pooling_param() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void LayerProto::set_has_pooling_param() {
  _has_bits_[0] |= 0x00040000u;
}
inline void LayerProto::clear_has_pooling_param() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void LayerProto::clear_pooling_param() {
  if (pooling_param_ != NULL) pooling_param_->::singa::PoolingProto::Clear();
  clear_has_pooling_param();
}
inline const ::singa::PoolingProto& LayerProto::pooling_param() const {
  return pooling_param_ != NULL ? *pooling_param_ : *default_instance_->pooling_param_;
}
inline ::singa::PoolingProto* LayerProto::mutable_pooling_param() {
  set_has_pooling_param();
  if (pooling_param_ == NULL) pooling_param_ = new ::singa::PoolingProto;
  return pooling_param_;
}
inline ::singa::PoolingProto* LayerProto::release_pooling_param() {
  clear_has_pooling_param();
  ::singa::PoolingProto* temp = pooling_param_;
  pooling_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_pooling_param(::singa::PoolingProto* pooling_param) {
  delete pooling_param_;
  pooling_param_ = pooling_param;
  if (pooling_param) {
    set_has_pooling_param();
  } else {
    clear_has_pooling_param();
  }
}

// repeated .singa.LayerProto sublayers = 35;
inline int LayerProto::sublayers_size() const {
  return sublayers_.size();
}
inline void LayerProto::clear_sublayers() {
  sublayers_.Clear();
}
inline const ::singa::LayerProto& LayerProto::sublayers(int index) const {
  return sublayers_.Get(index);
}
inline ::singa::LayerProto* LayerProto::mutable_sublayers(int index) {
  return sublayers_.Mutable(index);
}
inline ::singa::LayerProto* LayerProto::add_sublayers() {
  return sublayers_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >&
LayerProto::sublayers() const {
  return sublayers_;
}
inline ::google::protobuf::RepeatedPtrField< ::singa::LayerProto >*
LayerProto::mutable_sublayers() {
  return &sublayers_;
}

// optional .singa.SliceProto slice_param = 32;
inline bool LayerProto::has_slice_param() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void LayerProto::set_has_slice_param() {
  _has_bits_[0] |= 0x00100000u;
}
inline void LayerProto::clear_has_slice_param() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void LayerProto::clear_slice_param() {
  if (slice_param_ != NULL) slice_param_->::singa::SliceProto::Clear();
  clear_has_slice_param();
}
inline const ::singa::SliceProto& LayerProto::slice_param() const {
  return slice_param_ != NULL ? *slice_param_ : *default_instance_->slice_param_;
}
inline ::singa::SliceProto* LayerProto::mutable_slice_param() {
  set_has_slice_param();
  if (slice_param_ == NULL) slice_param_ = new ::singa::SliceProto;
  return slice_param_;
}
inline ::singa::SliceProto* LayerProto::release_slice_param() {
  clear_has_slice_param();
  ::singa::SliceProto* temp = slice_param_;
  slice_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_slice_param(::singa::SliceProto* slice_param) {
  delete slice_param_;
  slice_param_ = slice_param;
  if (slice_param) {
    set_has_slice_param();
  } else {
    clear_has_slice_param();
  }
}

// optional .singa.SplitProto split_param = 33;
inline bool LayerProto::has_split_param() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void LayerProto::set_has_split_param() {
  _has_bits_[0] |= 0x00200000u;
}
inline void LayerProto::clear_has_split_param() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void LayerProto::clear_split_param() {
  if (split_param_ != NULL) split_param_->::singa::SplitProto::Clear();
  clear_has_split_param();
}
inline const ::singa::SplitProto& LayerProto::split_param() const {
  return split_param_ != NULL ? *split_param_ : *default_instance_->split_param_;
}
inline ::singa::SplitProto* LayerProto::mutable_split_param() {
  set_has_split_param();
  if (split_param_ == NULL) split_param_ = new ::singa::SplitProto;
  return split_param_;
}
inline ::singa::SplitProto* LayerProto::release_split_param() {
  clear_has_split_param();
  ::singa::SplitProto* temp = split_param_;
  split_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_split_param(::singa::SplitProto* split_param) {
  delete split_param_;
  split_param_ = split_param;
  if (split_param) {
    set_has_split_param();
  } else {
    clear_has_split_param();
  }
}

// optional .singa.ReLUProto relu_param = 28;
inline bool LayerProto::has_relu_param() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void LayerProto::set_has_relu_param() {
  _has_bits_[0] |= 0x00400000u;
}
inline void LayerProto::clear_has_relu_param() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void LayerProto::clear_relu_param() {
  if (relu_param_ != NULL) relu_param_->::singa::ReLUProto::Clear();
  clear_has_relu_param();
}
inline const ::singa::ReLUProto& LayerProto::relu_param() const {
  return relu_param_ != NULL ? *relu_param_ : *default_instance_->relu_param_;
}
inline ::singa::ReLUProto* LayerProto::mutable_relu_param() {
  set_has_relu_param();
  if (relu_param_ == NULL) relu_param_ = new ::singa::ReLUProto;
  return relu_param_;
}
inline ::singa::ReLUProto* LayerProto::release_relu_param() {
  clear_has_relu_param();
  ::singa::ReLUProto* temp = relu_param_;
  relu_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_relu_param(::singa::ReLUProto* relu_param) {
  delete relu_param_;
  relu_param_ = relu_param;
  if (relu_param) {
    set_has_relu_param();
  } else {
    clear_has_relu_param();
  }
}

// optional .singa.RGBImage rgbimage_param = 34;
inline bool LayerProto::has_rgbimage_param() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void LayerProto::set_has_rgbimage_param() {
  _has_bits_[0] |= 0x00800000u;
}
inline void LayerProto::clear_has_rgbimage_param() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void LayerProto::clear_rgbimage_param() {
  if (rgbimage_param_ != NULL) rgbimage_param_->::singa::RGBImage::Clear();
  clear_has_rgbimage_param();
}
inline const ::singa::RGBImage& LayerProto::rgbimage_param() const {
  return rgbimage_param_ != NULL ? *rgbimage_param_ : *default_instance_->rgbimage_param_;
}
inline ::singa::RGBImage* LayerProto::mutable_rgbimage_param() {
  set_has_rgbimage_param();
  if (rgbimage_param_ == NULL) rgbimage_param_ = new ::singa::RGBImage;
  return rgbimage_param_;
}
inline ::singa::RGBImage* LayerProto::release_rgbimage_param() {
  clear_has_rgbimage_param();
  ::singa::RGBImage* temp = rgbimage_param_;
  rgbimage_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_rgbimage_param(::singa::RGBImage* rgbimage_param) {
  delete rgbimage_param_;
  rgbimage_param_ = rgbimage_param;
  if (rgbimage_param) {
    set_has_rgbimage_param();
  } else {
    clear_has_rgbimage_param();
  }
}

// optional .singa.SoftmaxLossProto softmaxloss_param = 29;
inline bool LayerProto::has_softmaxloss_param() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void LayerProto::set_has_softmaxloss_param() {
  _has_bits_[0] |= 0x01000000u;
}
inline void LayerProto::clear_has_softmaxloss_param() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void LayerProto::clear_softmaxloss_param() {
  if (softmaxloss_param_ != NULL) softmaxloss_param_->::singa::SoftmaxLossProto::Clear();
  clear_has_softmaxloss_param();
}
inline const ::singa::SoftmaxLossProto& LayerProto::softmaxloss_param() const {
  return softmaxloss_param_ != NULL ? *softmaxloss_param_ : *default_instance_->softmaxloss_param_;
}
inline ::singa::SoftmaxLossProto* LayerProto::mutable_softmaxloss_param() {
  set_has_softmaxloss_param();
  if (softmaxloss_param_ == NULL) softmaxloss_param_ = new ::singa::SoftmaxLossProto;
  return softmaxloss_param_;
}
inline ::singa::SoftmaxLossProto* LayerProto::release_softmaxloss_param() {
  clear_has_softmaxloss_param();
  ::singa::SoftmaxLossProto* temp = softmaxloss_param_;
  softmaxloss_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_softmaxloss_param(::singa::SoftmaxLossProto* softmaxloss_param) {
  delete softmaxloss_param_;
  softmaxloss_param_ = softmaxloss_param;
  if (softmaxloss_param) {
    set_has_softmaxloss_param();
  } else {
    clear_has_softmaxloss_param();
  }
}

// optional .singa.TanhProto tanh_param = 30;
inline bool LayerProto::has_tanh_param() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void LayerProto::set_has_tanh_param() {
  _has_bits_[0] |= 0x02000000u;
}
inline void LayerProto::clear_has_tanh_param() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void LayerProto::clear_tanh_param() {
  if (tanh_param_ != NULL) tanh_param_->::singa::TanhProto::Clear();
  clear_has_tanh_param();
}
inline const ::singa::TanhProto& LayerProto::tanh_param() const {
  return tanh_param_ != NULL ? *tanh_param_ : *default_instance_->tanh_param_;
}
inline ::singa::TanhProto* LayerProto::mutable_tanh_param() {
  set_has_tanh_param();
  if (tanh_param_ == NULL) tanh_param_ = new ::singa::TanhProto;
  return tanh_param_;
}
inline ::singa::TanhProto* LayerProto::release_tanh_param() {
  clear_has_tanh_param();
  ::singa::TanhProto* temp = tanh_param_;
  tanh_param_ = NULL;
  return temp;
}
inline void LayerProto::set_allocated_tanh_param(::singa::TanhProto* tanh_param) {
  delete tanh_param_;
  tanh_param_ = tanh_param;
  if (tanh_param) {
    set_has_tanh_param();
  } else {
    clear_has_tanh_param();
  }
}

// -------------------------------------------------------------------

// RGBImage

// optional float scale = 1 [default = 1];
inline bool RGBImage::has_scale() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RGBImage::set_has_scale() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RGBImage::clear_has_scale() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RGBImage::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float RGBImage::scale() const {
  return scale_;
}
inline void RGBImage::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional int32 cropsize = 2 [default = 0];
inline bool RGBImage::has_cropsize() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RGBImage::set_has_cropsize() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RGBImage::clear_has_cropsize() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RGBImage::clear_cropsize() {
  cropsize_ = 0;
  clear_has_cropsize();
}
inline ::google::protobuf::int32 RGBImage::cropsize() const {
  return cropsize_;
}
inline void RGBImage::set_cropsize(::google::protobuf::int32 value) {
  set_has_cropsize();
  cropsize_ = value;
}

// optional bool mirror = 3 [default = false];
inline bool RGBImage::has_mirror() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RGBImage::set_has_mirror() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RGBImage::clear_has_mirror() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RGBImage::clear_mirror() {
  mirror_ = false;
  clear_has_mirror();
}
inline bool RGBImage::mirror() const {
  return mirror_;
}
inline void RGBImage::set_mirror(bool value) {
  set_has_mirror();
  mirror_ = value;
}

// optional string meanfile = 4;
inline bool RGBImage::has_meanfile() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RGBImage::set_has_meanfile() {
  _has_bits_[0] |= 0x00000008u;
}
inline void RGBImage::clear_has_meanfile() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void RGBImage::clear_meanfile() {
  if (meanfile_ != &::google::protobuf::internal::kEmptyString) {
    meanfile_->clear();
  }
  clear_has_meanfile();
}
inline const ::std::string& RGBImage::meanfile() const {
  return *meanfile_;
}
inline void RGBImage::set_meanfile(const ::std::string& value) {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  meanfile_->assign(value);
}
inline void RGBImage::set_meanfile(const char* value) {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  meanfile_->assign(value);
}
inline void RGBImage::set_meanfile(const char* value, size_t size) {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  meanfile_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RGBImage::mutable_meanfile() {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  return meanfile_;
}
inline ::std::string* RGBImage::release_meanfile() {
  clear_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = meanfile_;
    meanfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RGBImage::set_allocated_meanfile(::std::string* meanfile) {
  if (meanfile_ != &::google::protobuf::internal::kEmptyString) {
    delete meanfile_;
  }
  if (meanfile) {
    set_has_meanfile();
    meanfile_ = meanfile;
  } else {
    clear_has_meanfile();
    meanfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// SplitProto

// optional int32 num_splits = 1;
inline bool SplitProto::has_num_splits() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SplitProto::set_has_num_splits() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SplitProto::clear_has_num_splits() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SplitProto::clear_num_splits() {
  num_splits_ = 0;
  clear_has_num_splits();
}
inline ::google::protobuf::int32 SplitProto::num_splits() const {
  return num_splits_;
}
inline void SplitProto::set_num_splits(::google::protobuf::int32 value) {
  set_has_num_splits();
  num_splits_ = value;
}

// -------------------------------------------------------------------

// TanhProto

// optional float outer_scale = 1 [default = 1];
inline bool TanhProto::has_outer_scale() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TanhProto::set_has_outer_scale() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TanhProto::clear_has_outer_scale() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TanhProto::clear_outer_scale() {
  outer_scale_ = 1;
  clear_has_outer_scale();
}
inline float TanhProto::outer_scale() const {
  return outer_scale_;
}
inline void TanhProto::set_outer_scale(float value) {
  set_has_outer_scale();
  outer_scale_ = value;
}

// optional float inner_scale = 2 [default = 1];
inline bool TanhProto::has_inner_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TanhProto::set_has_inner_scale() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TanhProto::clear_has_inner_scale() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TanhProto::clear_inner_scale() {
  inner_scale_ = 1;
  clear_has_inner_scale();
}
inline float TanhProto::inner_scale() const {
  return inner_scale_;
}
inline void TanhProto::set_inner_scale(float value) {
  set_has_inner_scale();
  inner_scale_ = value;
}

// -------------------------------------------------------------------

// SoftmaxLossProto

// optional int32 topk = 1 [default = 1];
inline bool SoftmaxLossProto::has_topk() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SoftmaxLossProto::set_has_topk() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SoftmaxLossProto::clear_has_topk() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SoftmaxLossProto::clear_topk() {
  topk_ = 1;
  clear_has_topk();
}
inline ::google::protobuf::int32 SoftmaxLossProto::topk() const {
  return topk_;
}
inline void SoftmaxLossProto::set_topk(::google::protobuf::int32 value) {
  set_has_topk();
  topk_ = value;
}

// optional float scale = 2 [default = 1];
inline bool SoftmaxLossProto::has_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SoftmaxLossProto::set_has_scale() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SoftmaxLossProto::clear_has_scale() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SoftmaxLossProto::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float SoftmaxLossProto::scale() const {
  return scale_;
}
inline void SoftmaxLossProto::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// -------------------------------------------------------------------

// ConvolutionProto

// optional uint32 num_filters = 1;
inline bool ConvolutionProto::has_num_filters() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConvolutionProto::set_has_num_filters() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConvolutionProto::clear_has_num_filters() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ConvolutionProto::clear_num_filters() {
  num_filters_ = 0u;
  clear_has_num_filters();
}
inline ::google::protobuf::uint32 ConvolutionProto::num_filters() const {
  return num_filters_;
}
inline void ConvolutionProto::set_num_filters(::google::protobuf::uint32 value) {
  set_has_num_filters();
  num_filters_ = value;
}

// optional bool bias_term = 2 [default = true];
inline bool ConvolutionProto::has_bias_term() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ConvolutionProto::set_has_bias_term() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ConvolutionProto::clear_has_bias_term() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ConvolutionProto::clear_bias_term() {
  bias_term_ = true;
  clear_has_bias_term();
}
inline bool ConvolutionProto::bias_term() const {
  return bias_term_;
}
inline void ConvolutionProto::set_bias_term(bool value) {
  set_has_bias_term();
  bias_term_ = value;
}

// optional uint32 pad = 3 [default = 0];
inline bool ConvolutionProto::has_pad() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ConvolutionProto::set_has_pad() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ConvolutionProto::clear_has_pad() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ConvolutionProto::clear_pad() {
  pad_ = 0u;
  clear_has_pad();
}
inline ::google::protobuf::uint32 ConvolutionProto::pad() const {
  return pad_;
}
inline void ConvolutionProto::set_pad(::google::protobuf::uint32 value) {
  set_has_pad();
  pad_ = value;
}

// optional uint32 stride = 4 [default = 1];
inline bool ConvolutionProto::has_stride() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ConvolutionProto::set_has_stride() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ConvolutionProto::clear_has_stride() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ConvolutionProto::clear_stride() {
  stride_ = 1u;
  clear_has_stride();
}
inline ::google::protobuf::uint32 ConvolutionProto::stride() const {
  return stride_;
}
inline void ConvolutionProto::set_stride(::google::protobuf::uint32 value) {
  set_has_stride();
  stride_ = value;
}

// required uint32 kernel = 5;
inline bool ConvolutionProto::has_kernel() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ConvolutionProto::set_has_kernel() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ConvolutionProto::clear_has_kernel() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ConvolutionProto::clear_kernel() {
  kernel_ = 0u;
  clear_has_kernel();
}
inline ::google::protobuf::uint32 ConvolutionProto::kernel() const {
  return kernel_;
}
inline void ConvolutionProto::set_kernel(::google::protobuf::uint32 value) {
  set_has_kernel();
  kernel_ = value;
}

// -------------------------------------------------------------------

// ConcateProto

// optional int32 concate_dimension = 1;
inline bool ConcateProto::has_concate_dimension() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConcateProto::set_has_concate_dimension() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConcateProto::clear_has_concate_dimension() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ConcateProto::clear_concate_dimension() {
  concate_dimension_ = 0;
  clear_has_concate_dimension();
}
inline ::google::protobuf::int32 ConcateProto::concate_dimension() const {
  return concate_dimension_;
}
inline void ConcateProto::set_concate_dimension(::google::protobuf::int32 value) {
  set_has_concate_dimension();
  concate_dimension_ = value;
}

// optional int32 concate_num = 2;
inline bool ConcateProto::has_concate_num() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ConcateProto::set_has_concate_num() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ConcateProto::clear_has_concate_num() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ConcateProto::clear_concate_num() {
  concate_num_ = 0;
  clear_has_concate_num();
}
inline ::google::protobuf::int32 ConcateProto::concate_num() const {
  return concate_num_;
}
inline void ConcateProto::set_concate_num(::google::protobuf::int32 value) {
  set_has_concate_num();
  concate_num_ = value;
}

// -------------------------------------------------------------------

// DataProto

// optional string source = 1;
inline bool DataProto::has_source() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DataProto::set_has_source() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DataProto::clear_has_source() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DataProto::clear_source() {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    source_->clear();
  }
  clear_has_source();
}
inline const ::std::string& DataProto::source() const {
  return *source_;
}
inline void DataProto::set_source(const ::std::string& value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void DataProto::set_source(const char* value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void DataProto::set_source(const char* value, size_t size) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DataProto::mutable_source() {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  return source_;
}
inline ::std::string* DataProto::release_source() {
  clear_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_;
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DataProto::set_allocated_source(::std::string* source) {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    delete source_;
  }
  if (source) {
    set_has_source();
    source_ = source;
  } else {
    clear_has_source();
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string path = 2;
inline bool DataProto::has_path() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DataProto::set_has_path() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DataProto::clear_has_path() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DataProto::clear_path() {
  if (path_ != &::google::protobuf::internal::kEmptyString) {
    path_->clear();
  }
  clear_has_path();
}
inline const ::std::string& DataProto::path() const {
  return *path_;
}
inline void DataProto::set_path(const ::std::string& value) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(value);
}
inline void DataProto::set_path(const char* value) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(value);
}
inline void DataProto::set_path(const char* value, size_t size) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DataProto::mutable_path() {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  return path_;
}
inline ::std::string* DataProto::release_path() {
  clear_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = path_;
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DataProto::set_allocated_path(::std::string* path) {
  if (path_ != &::google::protobuf::internal::kEmptyString) {
    delete path_;
  }
  if (path) {
    set_has_path();
    path_ = path;
  } else {
    clear_has_path();
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 batchsize = 4;
inline bool DataProto::has_batchsize() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DataProto::set_has_batchsize() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DataProto::clear_has_batchsize() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DataProto::clear_batchsize() {
  batchsize_ = 0u;
  clear_has_batchsize();
}
inline ::google::protobuf::uint32 DataProto::batchsize() const {
  return batchsize_;
}
inline void DataProto::set_batchsize(::google::protobuf::uint32 value) {
  set_has_batchsize();
  batchsize_ = value;
}

// optional uint32 random_skip = 5 [default = 0];
inline bool DataProto::has_random_skip() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DataProto::set_has_random_skip() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DataProto::clear_has_random_skip() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DataProto::clear_random_skip() {
  random_skip_ = 0u;
  clear_has_random_skip();
}
inline ::google::protobuf::uint32 DataProto::random_skip() const {
  return random_skip_;
}
inline void DataProto::set_random_skip(::google::protobuf::uint32 value) {
  set_has_random_skip();
  random_skip_ = value;
}

// -------------------------------------------------------------------

// MnistProto

// optional int32 kernel = 1 [default = 0];
inline bool MnistProto::has_kernel() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MnistProto::set_has_kernel() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MnistProto::clear_has_kernel() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MnistProto::clear_kernel() {
  kernel_ = 0;
  clear_has_kernel();
}
inline ::google::protobuf::int32 MnistProto::kernel() const {
  return kernel_;
}
inline void MnistProto::set_kernel(::google::protobuf::int32 value) {
  set_has_kernel();
  kernel_ = value;
}

// optional float sigma = 2 [default = 0];
inline bool MnistProto::has_sigma() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MnistProto::set_has_sigma() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MnistProto::clear_has_sigma() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MnistProto::clear_sigma() {
  sigma_ = 0;
  clear_has_sigma();
}
inline float MnistProto::sigma() const {
  return sigma_;
}
inline void MnistProto::set_sigma(float value) {
  set_has_sigma();
  sigma_ = value;
}

// optional float alpha = 3 [default = 0];
inline bool MnistProto::has_alpha() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MnistProto::set_has_alpha() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MnistProto::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MnistProto::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float MnistProto::alpha() const {
  return alpha_;
}
inline void MnistProto::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// optional float beta = 4 [default = 0];
inline bool MnistProto::has_beta() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MnistProto::set_has_beta() {
  _has_bits_[0] |= 0x00000008u;
}
inline void MnistProto::clear_has_beta() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void MnistProto::clear_beta() {
  beta_ = 0;
  clear_has_beta();
}
inline float MnistProto::beta() const {
  return beta_;
}
inline void MnistProto::set_beta(float value) {
  set_has_beta();
  beta_ = value;
}

// optional float gamma = 5 [default = 0];
inline bool MnistProto::has_gamma() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void MnistProto::set_has_gamma() {
  _has_bits_[0] |= 0x00000010u;
}
inline void MnistProto::clear_has_gamma() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void MnistProto::clear_gamma() {
  gamma_ = 0;
  clear_has_gamma();
}
inline float MnistProto::gamma() const {
  return gamma_;
}
inline void MnistProto::set_gamma(float value) {
  set_has_gamma();
  gamma_ = value;
}

// optional int32 resize = 6 [default = 0];
inline bool MnistProto::has_resize() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void MnistProto::set_has_resize() {
  _has_bits_[0] |= 0x00000020u;
}
inline void MnistProto::clear_has_resize() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void MnistProto::clear_resize() {
  resize_ = 0;
  clear_has_resize();
}
inline ::google::protobuf::int32 MnistProto::resize() const {
  return resize_;
}
inline void MnistProto::set_resize(::google::protobuf::int32 value) {
  set_has_resize();
  resize_ = value;
}

// optional int32 elastic_freq = 7 [default = 0];
inline bool MnistProto::has_elastic_freq() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void MnistProto::set_has_elastic_freq() {
  _has_bits_[0] |= 0x00000040u;
}
inline void MnistProto::clear_has_elastic_freq() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void MnistProto::clear_elastic_freq() {
  elastic_freq_ = 0;
  clear_has_elastic_freq();
}
inline ::google::protobuf::int32 MnistProto::elastic_freq() const {
  return elastic_freq_;
}
inline void MnistProto::set_elastic_freq(::google::protobuf::int32 value) {
  set_has_elastic_freq();
  elastic_freq_ = value;
}

// optional float norm_a = 8 [default = 1];
inline bool MnistProto::has_norm_a() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void MnistProto::set_has_norm_a() {
  _has_bits_[0] |= 0x00000080u;
}
inline void MnistProto::clear_has_norm_a() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void MnistProto::clear_norm_a() {
  norm_a_ = 1;
  clear_has_norm_a();
}
inline float MnistProto::norm_a() const {
  return norm_a_;
}
inline void MnistProto::set_norm_a(float value) {
  set_has_norm_a();
  norm_a_ = value;
}

// optional float norm_b = 9 [default = 0];
inline bool MnistProto::has_norm_b() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void MnistProto::set_has_norm_b() {
  _has_bits_[0] |= 0x00000100u;
}
inline void MnistProto::clear_has_norm_b() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void MnistProto::clear_norm_b() {
  norm_b_ = 0;
  clear_has_norm_b();
}
inline float MnistProto::norm_b() const {
  return norm_b_;
}
inline void MnistProto::set_norm_b(float value) {
  set_has_norm_b();
  norm_b_ = value;
}

// -------------------------------------------------------------------

// DropoutProto

// optional float dropout_ratio = 1 [default = 0.5];
inline bool DropoutProto::has_dropout_ratio() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DropoutProto::set_has_dropout_ratio() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DropoutProto::clear_has_dropout_ratio() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DropoutProto::clear_dropout_ratio() {
  dropout_ratio_ = 0.5f;
  clear_has_dropout_ratio();
}
inline float DropoutProto::dropout_ratio() const {
  return dropout_ratio_;
}
inline void DropoutProto::set_dropout_ratio(float value) {
  set_has_dropout_ratio();
  dropout_ratio_ = value;
}

// -------------------------------------------------------------------

// InnerProductProto

// optional uint32 num_output = 1;
inline bool InnerProductProto::has_num_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InnerProductProto::set_has_num_output() {
  _has_bits_[0] |= 0x00000001u;
}
inline void InnerProductProto::clear_has_num_output() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void InnerProductProto::clear_num_output() {
  num_output_ = 0u;
  clear_has_num_output();
}
inline ::google::protobuf::uint32 InnerProductProto::num_output() const {
  return num_output_;
}
inline void InnerProductProto::set_num_output(::google::protobuf::uint32 value) {
  set_has_num_output();
  num_output_ = value;
}

// optional bool bias_term = 2 [default = true];
inline bool InnerProductProto::has_bias_term() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void InnerProductProto::set_has_bias_term() {
  _has_bits_[0] |= 0x00000002u;
}
inline void InnerProductProto::clear_has_bias_term() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void InnerProductProto::clear_bias_term() {
  bias_term_ = true;
  clear_has_bias_term();
}
inline bool InnerProductProto::bias_term() const {
  return bias_term_;
}
inline void InnerProductProto::set_bias_term(bool value) {
  set_has_bias_term();
  bias_term_ = value;
}

// -------------------------------------------------------------------

// LRNProto

// optional uint32 local_size = 1 [default = 5];
inline bool LRNProto::has_local_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LRNProto::set_has_local_size() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LRNProto::clear_has_local_size() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LRNProto::clear_local_size() {
  local_size_ = 5u;
  clear_has_local_size();
}
inline ::google::protobuf::uint32 LRNProto::local_size() const {
  return local_size_;
}
inline void LRNProto::set_local_size(::google::protobuf::uint32 value) {
  set_has_local_size();
  local_size_ = value;
}

// optional float alpha = 2 [default = 1];
inline bool LRNProto::has_alpha() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LRNProto::set_has_alpha() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LRNProto::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LRNProto::clear_alpha() {
  alpha_ = 1;
  clear_has_alpha();
}
inline float LRNProto::alpha() const {
  return alpha_;
}
inline void LRNProto::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// optional float beta = 3 [default = 0.75];
inline bool LRNProto::has_beta() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LRNProto::set_has_beta() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LRNProto::clear_has_beta() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LRNProto::clear_beta() {
  beta_ = 0.75f;
  clear_has_beta();
}
inline float LRNProto::beta() const {
  return beta_;
}
inline void LRNProto::set_beta(float value) {
  set_has_beta();
  beta_ = value;
}

// optional .singa.LRNProto.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
inline bool LRNProto::has_norm_region() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LRNProto::set_has_norm_region() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LRNProto::clear_has_norm_region() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LRNProto::clear_norm_region() {
  norm_region_ = 0;
  clear_has_norm_region();
}
inline ::singa::LRNProto_NormRegion LRNProto::norm_region() const {
  return static_cast< ::singa::LRNProto_NormRegion >(norm_region_);
}
inline void LRNProto::set_norm_region(::singa::LRNProto_NormRegion value) {
  assert(::singa::LRNProto_NormRegion_IsValid(value));
  set_has_norm_region();
  norm_region_ = value;
}

// optional float knorm = 5 [default = 1];
inline bool LRNProto::has_knorm() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LRNProto::set_has_knorm() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LRNProto::clear_has_knorm() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LRNProto::clear_knorm() {
  knorm_ = 1;
  clear_has_knorm();
}
inline float LRNProto::knorm() const {
  return knorm_;
}
inline void LRNProto::set_knorm(float value) {
  set_has_knorm();
  knorm_ = value;
}

// -------------------------------------------------------------------

// PoolingProto

// optional .singa.PoolingProto.PoolMethod pool = 1 [default = MAX];
inline bool PoolingProto::has_pool() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PoolingProto::set_has_pool() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PoolingProto::clear_has_pool() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PoolingProto::clear_pool() {
  pool_ = 0;
  clear_has_pool();
}
inline ::singa::PoolingProto_PoolMethod PoolingProto::pool() const {
  return static_cast< ::singa::PoolingProto_PoolMethod >(pool_);
}
inline void PoolingProto::set_pool(::singa::PoolingProto_PoolMethod value) {
  assert(::singa::PoolingProto_PoolMethod_IsValid(value));
  set_has_pool();
  pool_ = value;
}

// required uint32 kernel = 2;
inline bool PoolingProto::has_kernel() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PoolingProto::set_has_kernel() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PoolingProto::clear_has_kernel() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PoolingProto::clear_kernel() {
  kernel_ = 0u;
  clear_has_kernel();
}
inline ::google::protobuf::uint32 PoolingProto::kernel() const {
  return kernel_;
}
inline void PoolingProto::set_kernel(::google::protobuf::uint32 value) {
  set_has_kernel();
  kernel_ = value;
}

// optional uint32 pad = 4 [default = 0];
inline bool PoolingProto::has_pad() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PoolingProto::set_has_pad() {
  _has_bits_[0] |= 0x00000004u;
}
inline void PoolingProto::clear_has_pad() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void PoolingProto::clear_pad() {
  pad_ = 0u;
  clear_has_pad();
}
inline ::google::protobuf::uint32 PoolingProto::pad() const {
  return pad_;
}
inline void PoolingProto::set_pad(::google::protobuf::uint32 value) {
  set_has_pad();
  pad_ = value;
}

// optional uint32 stride = 3 [default = 1];
inline bool PoolingProto::has_stride() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PoolingProto::set_has_stride() {
  _has_bits_[0] |= 0x00000008u;
}
inline void PoolingProto::clear_has_stride() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void PoolingProto::clear_stride() {
  stride_ = 1u;
  clear_has_stride();
}
inline ::google::protobuf::uint32 PoolingProto::stride() const {
  return stride_;
}
inline void PoolingProto::set_stride(::google::protobuf::uint32 value) {
  set_has_stride();
  stride_ = value;
}

// -------------------------------------------------------------------

// SliceProto

// optional int32 slice_dimension = 1;
inline bool SliceProto::has_slice_dimension() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SliceProto::set_has_slice_dimension() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SliceProto::clear_has_slice_dimension() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SliceProto::clear_slice_dimension() {
  slice_dimension_ = 0;
  clear_has_slice_dimension();
}
inline ::google::protobuf::int32 SliceProto::slice_dimension() const {
  return slice_dimension_;
}
inline void SliceProto::set_slice_dimension(::google::protobuf::int32 value) {
  set_has_slice_dimension();
  slice_dimension_ = value;
}

// optional int32 slice_num = 2;
inline bool SliceProto::has_slice_num() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SliceProto::set_has_slice_num() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SliceProto::clear_has_slice_num() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SliceProto::clear_slice_num() {
  slice_num_ = 0;
  clear_has_slice_num();
}
inline ::google::protobuf::int32 SliceProto::slice_num() const {
  return slice_num_;
}
inline void SliceProto::set_slice_num(::google::protobuf::int32 value) {
  set_has_slice_num();
  slice_num_ = value;
}

// -------------------------------------------------------------------

// ReLUProto

// optional float negative_slope = 1 [default = 0];
inline bool ReLUProto::has_negative_slope() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReLUProto::set_has_negative_slope() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReLUProto::clear_has_negative_slope() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReLUProto::clear_negative_slope() {
  negative_slope_ = 0;
  clear_has_negative_slope();
}
inline float ReLUProto::negative_slope() const {
  return negative_slope_;
}
inline void ReLUProto::set_negative_slope(float value) {
  set_has_negative_slope();
  negative_slope_ = value;
}

// -------------------------------------------------------------------

// Record

// optional .singa.Record.Type type = 1 [default = kSingleLabelImage];
inline bool Record::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Record::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Record::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Record::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::singa::Record_Type Record::type() const {
  return static_cast< ::singa::Record_Type >(type_);
}
inline void Record::set_type(::singa::Record_Type value) {
  assert(::singa::Record_Type_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional .singa.SingleLabelImageRecord image = 2;
inline bool Record::has_image() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Record::set_has_image() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Record::clear_has_image() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Record::clear_image() {
  if (image_ != NULL) image_->::singa::SingleLabelImageRecord::Clear();
  clear_has_image();
}
inline const ::singa::SingleLabelImageRecord& Record::image() const {
  return image_ != NULL ? *image_ : *default_instance_->image_;
}
inline ::singa::SingleLabelImageRecord* Record::mutable_image() {
  set_has_image();
  if (image_ == NULL) image_ = new ::singa::SingleLabelImageRecord;
  return image_;
}
inline ::singa::SingleLabelImageRecord* Record::release_image() {
  clear_has_image();
  ::singa::SingleLabelImageRecord* temp = image_;
  image_ = NULL;
  return temp;
}
inline void Record::set_allocated_image(::singa::SingleLabelImageRecord* image) {
  delete image_;
  image_ = image;
  if (image) {
    set_has_image();
  } else {
    clear_has_image();
  }
}

// -------------------------------------------------------------------

// Datum

// optional int32 channels = 1;
inline bool Datum::has_channels() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Datum::set_has_channels() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Datum::clear_has_channels() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Datum::clear_channels() {
  channels_ = 0;
  clear_has_channels();
}
inline ::google::protobuf::int32 Datum::channels() const {
  return channels_;
}
inline void Datum::set_channels(::google::protobuf::int32 value) {
  set_has_channels();
  channels_ = value;
}

// optional int32 height = 2;
inline bool Datum::has_height() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Datum::set_has_height() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Datum::clear_has_height() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Datum::clear_height() {
  height_ = 0;
  clear_has_height();
}
inline ::google::protobuf::int32 Datum::height() const {
  return height_;
}
inline void Datum::set_height(::google::protobuf::int32 value) {
  set_has_height();
  height_ = value;
}

// optional int32 width = 3;
inline bool Datum::has_width() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Datum::set_has_width() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Datum::clear_has_width() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Datum::clear_width() {
  width_ = 0;
  clear_has_width();
}
inline ::google::protobuf::int32 Datum::width() const {
  return width_;
}
inline void Datum::set_width(::google::protobuf::int32 value) {
  set_has_width();
  width_ = value;
}

// optional bytes data = 4;
inline bool Datum::has_data() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Datum::set_has_data() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Datum::clear_has_data() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Datum::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& Datum::data() const {
  return *data_;
}
inline void Datum::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Datum::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Datum::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Datum::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* Datum::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Datum::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 label = 5;
inline bool Datum::has_label() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Datum::set_has_label() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Datum::clear_has_label() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Datum::clear_label() {
  label_ = 0;
  clear_has_label();
}
inline ::google::protobuf::int32 Datum::label() const {
  return label_;
}
inline void Datum::set_label(::google::protobuf::int32 value) {
  set_has_label();
  label_ = value;
}

// repeated float float_data = 6;
inline int Datum::float_data_size() const {
  return float_data_.size();
}
inline void Datum::clear_float_data() {
  float_data_.Clear();
}
inline float Datum::float_data(int index) const {
  return float_data_.Get(index);
}
inline void Datum::set_float_data(int index, float value) {
  float_data_.Set(index, value);
}
inline void Datum::add_float_data(float value) {
  float_data_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
Datum::float_data() const {
  return float_data_;
}
inline ::google::protobuf::RepeatedField< float >*
Datum::mutable_float_data() {
  return &float_data_;
}

// optional bool encoded = 7 [default = false];
inline bool Datum::has_encoded() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Datum::set_has_encoded() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Datum::clear_has_encoded() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Datum::clear_encoded() {
  encoded_ = false;
  clear_has_encoded();
}
inline bool Datum::encoded() const {
  return encoded_;
}
inline void Datum::set_encoded(bool value) {
  set_has_encoded();
  encoded_ = value;
}

// -------------------------------------------------------------------

// SingleLabelImageRecord

// repeated int32 shape = 1;
inline int SingleLabelImageRecord::shape_size() const {
  return shape_.size();
}
inline void SingleLabelImageRecord::clear_shape() {
  shape_.Clear();
}
inline ::google::protobuf::int32 SingleLabelImageRecord::shape(int index) const {
  return shape_.Get(index);
}
inline void SingleLabelImageRecord::set_shape(int index, ::google::protobuf::int32 value) {
  shape_.Set(index, value);
}
inline void SingleLabelImageRecord::add_shape(::google::protobuf::int32 value) {
  shape_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SingleLabelImageRecord::shape() const {
  return shape_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SingleLabelImageRecord::mutable_shape() {
  return &shape_;
}

// optional int32 label = 2;
inline bool SingleLabelImageRecord::has_label() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SingleLabelImageRecord::set_has_label() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SingleLabelImageRecord::clear_has_label() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SingleLabelImageRecord::clear_label() {
  label_ = 0;
  clear_has_label();
}
inline ::google::protobuf::int32 SingleLabelImageRecord::label() const {
  return label_;
}
inline void SingleLabelImageRecord::set_label(::google::protobuf::int32 value) {
  set_has_label();
  label_ = value;
}

// optional bytes pixel = 3;
inline bool SingleLabelImageRecord::has_pixel() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SingleLabelImageRecord::set_has_pixel() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SingleLabelImageRecord::clear_has_pixel() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SingleLabelImageRecord::clear_pixel() {
  if (pixel_ != &::google::protobuf::internal::kEmptyString) {
    pixel_->clear();
  }
  clear_has_pixel();
}
inline const ::std::string& SingleLabelImageRecord::pixel() const {
  return *pixel_;
}
inline void SingleLabelImageRecord::set_pixel(const ::std::string& value) {
  set_has_pixel();
  if (pixel_ == &::google::protobuf::internal::kEmptyString) {
    pixel_ = new ::std::string;
  }
  pixel_->assign(value);
}
inline void SingleLabelImageRecord::set_pixel(const char* value) {
  set_has_pixel();
  if (pixel_ == &::google::protobuf::internal::kEmptyString) {
    pixel_ = new ::std::string;
  }
  pixel_->assign(value);
}
inline void SingleLabelImageRecord::set_pixel(const void* value, size_t size) {
  set_has_pixel();
  if (pixel_ == &::google::protobuf::internal::kEmptyString) {
    pixel_ = new ::std::string;
  }
  pixel_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SingleLabelImageRecord::mutable_pixel() {
  set_has_pixel();
  if (pixel_ == &::google::protobuf::internal::kEmptyString) {
    pixel_ = new ::std::string;
  }
  return pixel_;
}
inline ::std::string* SingleLabelImageRecord::release_pixel() {
  clear_has_pixel();
  if (pixel_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = pixel_;
    pixel_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SingleLabelImageRecord::set_allocated_pixel(::std::string* pixel) {
  if (pixel_ != &::google::protobuf::internal::kEmptyString) {
    delete pixel_;
  }
  if (pixel) {
    set_has_pixel();
    pixel_ = pixel;
  } else {
    clear_has_pixel();
    pixel_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated float data = 4;
inline int SingleLabelImageRecord::data_size() const {
  return data_.size();
}
inline void SingleLabelImageRecord::clear_data() {
  data_.Clear();
}
inline float SingleLabelImageRecord::data(int index) const {
  return data_.Get(index);
}
inline void SingleLabelImageRecord::set_data(int index, float value) {
  data_.Set(index, value);
}
inline void SingleLabelImageRecord::add_data(float value) {
  data_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
SingleLabelImageRecord::data() const {
  return data_;
}
inline ::google::protobuf::RepeatedField< float >*
SingleLabelImageRecord::mutable_data() {
  return &data_;
}

// -------------------------------------------------------------------

// UpdaterProto

// optional float momentum = 4 [default = 0];
inline bool UpdaterProto::has_momentum() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UpdaterProto::set_has_momentum() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UpdaterProto::clear_has_momentum() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UpdaterProto::clear_momentum() {
  momentum_ = 0;
  clear_has_momentum();
}
inline float UpdaterProto::momentum() const {
  return momentum_;
}
inline void UpdaterProto::set_momentum(float value) {
  set_has_momentum();
  momentum_ = value;
}

// optional float weight_decay = 5 [default = 0];
inline bool UpdaterProto::has_weight_decay() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UpdaterProto::set_has_weight_decay() {
  _has_bits_[0] |= 0x00000002u;
}
inline void UpdaterProto::clear_has_weight_decay() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void UpdaterProto::clear_weight_decay() {
  weight_decay_ = 0;
  clear_has_weight_decay();
}
inline float UpdaterProto::weight_decay() const {
  return weight_decay_;
}
inline void UpdaterProto::set_weight_decay(float value) {
  set_has_weight_decay();
  weight_decay_ = value;
}

// optional float gamma = 6 [default = 1];
inline bool UpdaterProto::has_gamma() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UpdaterProto::set_has_gamma() {
  _has_bits_[0] |= 0x00000004u;
}
inline void UpdaterProto::clear_has_gamma() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void UpdaterProto::clear_gamma() {
  gamma_ = 1;
  clear_has_gamma();
}
inline float UpdaterProto::gamma() const {
  return gamma_;
}
inline void UpdaterProto::set_gamma(float value) {
  set_has_gamma();
  gamma_ = value;
}

// optional float pow = 7 [default = 0];
inline bool UpdaterProto::has_pow() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UpdaterProto::set_has_pow() {
  _has_bits_[0] |= 0x00000008u;
}
inline void UpdaterProto::clear_has_pow() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void UpdaterProto::clear_pow() {
  pow_ = 0;
  clear_has_pow();
}
inline float UpdaterProto::pow() const {
  return pow_;
}
inline void UpdaterProto::set_pow(float value) {
  set_has_pow();
  pow_ = value;
}

// optional float delta = 8 [default = 1e-07];
inline bool UpdaterProto::has_delta() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UpdaterProto::set_has_delta() {
  _has_bits_[0] |= 0x00000010u;
}
inline void UpdaterProto::clear_has_delta() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void UpdaterProto::clear_delta() {
  delta_ = 1e-07f;
  clear_has_delta();
}
inline float UpdaterProto::delta() const {
  return delta_;
}
inline void UpdaterProto::set_delta(float value) {
  set_has_delta();
  delta_ = value;
}

// optional float rho = 9 [default = 0.9];
inline bool UpdaterProto::has_rho() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void UpdaterProto::set_has_rho() {
  _has_bits_[0] |= 0x00000020u;
}
inline void UpdaterProto::clear_has_rho() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void UpdaterProto::clear_rho() {
  rho_ = 0.9f;
  clear_has_rho();
}
inline float UpdaterProto::rho() const {
  return rho_;
}
inline void UpdaterProto::set_rho(float value) {
  set_has_rho();
  rho_ = value;
}

// optional float base_learning_rate = 12;
inline bool UpdaterProto::has_base_learning_rate() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void UpdaterProto::set_has_base_learning_rate() {
  _has_bits_[0] |= 0x00000040u;
}
inline void UpdaterProto::clear_has_base_learning_rate() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void UpdaterProto::clear_base_learning_rate() {
  base_learning_rate_ = 0;
  clear_has_base_learning_rate();
}
inline float UpdaterProto::base_learning_rate() const {
  return base_learning_rate_;
}
inline void UpdaterProto::set_base_learning_rate(float value) {
  set_has_base_learning_rate();
  base_learning_rate_ = value;
}

// optional float final_learning_rate = 13;
inline bool UpdaterProto::has_final_learning_rate() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void UpdaterProto::set_has_final_learning_rate() {
  _has_bits_[0] |= 0x00000080u;
}
inline void UpdaterProto::clear_has_final_learning_rate() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void UpdaterProto::clear_final_learning_rate() {
  final_learning_rate_ = 0;
  clear_has_final_learning_rate();
}
inline float UpdaterProto::final_learning_rate() const {
  return final_learning_rate_;
}
inline void UpdaterProto::set_final_learning_rate(float value) {
  set_has_final_learning_rate();
  final_learning_rate_ = value;
}

// optional int32 learning_rate_change_frequency = 14;
inline bool UpdaterProto::has_learning_rate_change_frequency() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void UpdaterProto::set_has_learning_rate_change_frequency() {
  _has_bits_[0] |= 0x00000100u;
}
inline void UpdaterProto::clear_has_learning_rate_change_frequency() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void UpdaterProto::clear_learning_rate_change_frequency() {
  learning_rate_change_frequency_ = 0;
  clear_has_learning_rate_change_frequency();
}
inline ::google::protobuf::int32 UpdaterProto::learning_rate_change_frequency() const {
  return learning_rate_change_frequency_;
}
inline void UpdaterProto::set_learning_rate_change_frequency(::google::protobuf::int32 value) {
  set_has_learning_rate_change_frequency();
  learning_rate_change_frequency_ = value;
}

// optional .singa.UpdaterProto.ChangeProto learning_rate_change_method = 16 [default = kFixed];
inline bool UpdaterProto::has_learning_rate_change_method() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void UpdaterProto::set_has_learning_rate_change_method() {
  _has_bits_[0] |= 0x00000200u;
}
inline void UpdaterProto::clear_has_learning_rate_change_method() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void UpdaterProto::clear_learning_rate_change_method() {
  learning_rate_change_method_ = 0;
  clear_has_learning_rate_change_method();
}
inline ::singa::UpdaterProto_ChangeProto UpdaterProto::learning_rate_change_method() const {
  return static_cast< ::singa::UpdaterProto_ChangeProto >(learning_rate_change_method_);
}
inline void UpdaterProto::set_learning_rate_change_method(::singa::UpdaterProto_ChangeProto value) {
  assert(::singa::UpdaterProto_ChangeProto_IsValid(value));
  set_has_learning_rate_change_method();
  learning_rate_change_method_ = value;
}

// optional int32 sync_frequency = 17 [default = 1];
inline bool UpdaterProto::has_sync_frequency() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void UpdaterProto::set_has_sync_frequency() {
  _has_bits_[0] |= 0x00000400u;
}
inline void UpdaterProto::clear_has_sync_frequency() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void UpdaterProto::clear_sync_frequency() {
  sync_frequency_ = 1;
  clear_has_sync_frequency();
}
inline ::google::protobuf::int32 UpdaterProto::sync_frequency() const {
  return sync_frequency_;
}
inline void UpdaterProto::set_sync_frequency(::google::protobuf::int32 value) {
  set_has_sync_frequency();
  sync_frequency_ = value;
}

// optional float moving_rate = 26 [default = 0];
inline bool UpdaterProto::has_moving_rate() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void UpdaterProto::set_has_moving_rate() {
  _has_bits_[0] |= 0x00000800u;
}
inline void UpdaterProto::clear_has_moving_rate() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void UpdaterProto::clear_moving_rate() {
  moving_rate_ = 0;
  clear_has_moving_rate();
}
inline float UpdaterProto::moving_rate() const {
  return moving_rate_;
}
inline void UpdaterProto::set_moving_rate(float value) {
  set_has_moving_rate();
  moving_rate_ = value;
}

// optional string param_type = 27 [default = "Param"];
inline bool UpdaterProto::has_param_type() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void UpdaterProto::set_has_param_type() {
  _has_bits_[0] |= 0x00001000u;
}
inline void UpdaterProto::clear_has_param_type() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void UpdaterProto::clear_param_type() {
  if (param_type_ != _default_param_type_) {
    param_type_->assign(*_default_param_type_);
  }
  clear_has_param_type();
}
inline const ::std::string& UpdaterProto::param_type() const {
  return *param_type_;
}
inline void UpdaterProto::set_param_type(const ::std::string& value) {
  set_has_param_type();
  if (param_type_ == _default_param_type_) {
    param_type_ = new ::std::string;
  }
  param_type_->assign(value);
}
inline void UpdaterProto::set_param_type(const char* value) {
  set_has_param_type();
  if (param_type_ == _default_param_type_) {
    param_type_ = new ::std::string;
  }
  param_type_->assign(value);
}
inline void UpdaterProto::set_param_type(const char* value, size_t size) {
  set_has_param_type();
  if (param_type_ == _default_param_type_) {
    param_type_ = new ::std::string;
  }
  param_type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UpdaterProto::mutable_param_type() {
  set_has_param_type();
  if (param_type_ == _default_param_type_) {
    param_type_ = new ::std::string(*_default_param_type_);
  }
  return param_type_;
}
inline ::std::string* UpdaterProto::release_param_type() {
  clear_has_param_type();
  if (param_type_ == _default_param_type_) {
    return NULL;
  } else {
    ::std::string* temp = param_type_;
    param_type_ = const_cast< ::std::string*>(_default_param_type_);
    return temp;
  }
}
inline void UpdaterProto::set_allocated_param_type(::std::string* param_type) {
  if (param_type_ != _default_param_type_) {
    delete param_type_;
  }
  if (param_type) {
    set_has_param_type();
    param_type_ = param_type;
  } else {
    clear_has_param_type();
    param_type_ = const_cast< ::std::string*>(_default_param_type_);
  }
}

// repeated int32 step = 28;
inline int UpdaterProto::step_size() const {
  return step_.size();
}
inline void UpdaterProto::clear_step() {
  step_.Clear();
}
inline ::google::protobuf::int32 UpdaterProto::step(int index) const {
  return step_.Get(index);
}
inline void UpdaterProto::set_step(int index, ::google::protobuf::int32 value) {
  step_.Set(index, value);
}
inline void UpdaterProto::add_step(::google::protobuf::int32 value) {
  step_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
UpdaterProto::step() const {
  return step_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
UpdaterProto::mutable_step() {
  return &step_;
}

// repeated float step_lr = 29;
inline int UpdaterProto::step_lr_size() const {
  return step_lr_.size();
}
inline void UpdaterProto::clear_step_lr() {
  step_lr_.Clear();
}
inline float UpdaterProto::step_lr(int index) const {
  return step_lr_.Get(index);
}
inline void UpdaterProto::set_step_lr(int index, float value) {
  step_lr_.Set(index, value);
}
inline void UpdaterProto::add_step_lr(float value) {
  step_lr_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
UpdaterProto::step_lr() const {
  return step_lr_;
}
inline ::google::protobuf::RepeatedField< float >*
UpdaterProto::mutable_step_lr() {
  return &step_lr_;
}

// -------------------------------------------------------------------

// BlobProto

// optional int32 num = 1 [default = 0];
inline bool BlobProto::has_num() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlobProto::set_has_num() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BlobProto::clear_has_num() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BlobProto::clear_num() {
  num_ = 0;
  clear_has_num();
}
inline ::google::protobuf::int32 BlobProto::num() const {
  return num_;
}
inline void BlobProto::set_num(::google::protobuf::int32 value) {
  set_has_num();
  num_ = value;
}

// optional int32 channels = 2 [default = 0];
inline bool BlobProto::has_channels() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlobProto::set_has_channels() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BlobProto::clear_has_channels() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BlobProto::clear_channels() {
  channels_ = 0;
  clear_has_channels();
}
inline ::google::protobuf::int32 BlobProto::channels() const {
  return channels_;
}
inline void BlobProto::set_channels(::google::protobuf::int32 value) {
  set_has_channels();
  channels_ = value;
}

// optional int32 height = 3 [default = 0];
inline bool BlobProto::has_height() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BlobProto::set_has_height() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BlobProto::clear_has_height() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BlobProto::clear_height() {
  height_ = 0;
  clear_has_height();
}
inline ::google::protobuf::int32 BlobProto::height() const {
  return height_;
}
inline void BlobProto::set_height(::google::protobuf::int32 value) {
  set_has_height();
  height_ = value;
}

// optional int32 width = 4 [default = 0];
inline bool BlobProto::has_width() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BlobProto::set_has_width() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BlobProto::clear_has_width() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BlobProto::clear_width() {
  width_ = 0;
  clear_has_width();
}
inline ::google::protobuf::int32 BlobProto::width() const {
  return width_;
}
inline void BlobProto::set_width(::google::protobuf::int32 value) {
  set_has_width();
  width_ = value;
}

// repeated float data = 5 [packed = true];
inline int BlobProto::data_size() const {
  return data_.size();
}
inline void BlobProto::clear_data() {
  data_.Clear();
}
inline float BlobProto::data(int index) const {
  return data_.Get(index);
}
inline void BlobProto::set_data(int index, float value) {
  data_.Set(index, value);
}
inline void BlobProto::add_data(float value) {
  data_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BlobProto::data() const {
  return data_;
}
inline ::google::protobuf::RepeatedField< float >*
BlobProto::mutable_data() {
  return &data_;
}

// repeated float diff = 6 [packed = true];
inline int BlobProto::diff_size() const {
  return diff_.size();
}
inline void BlobProto::clear_diff() {
  diff_.Clear();
}
inline float BlobProto::diff(int index) const {
  return diff_.Get(index);
}
inline void BlobProto::set_diff(int index, float value) {
  diff_.Set(index, value);
}
inline void BlobProto::add_diff(float value) {
  diff_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BlobProto::diff() const {
  return diff_;
}
inline ::google::protobuf::RepeatedField< float >*
BlobProto::mutable_diff() {
  return &diff_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace singa

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::ModelProto_GradCalcAlg>() {
  return ::singa::ModelProto_GradCalcAlg_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::ParamProto_InitMethod>() {
  return ::singa::ParamProto_InitMethod_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::LRNProto_NormRegion>() {
  return ::singa::LRNProto_NormRegion_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::PoolingProto_PoolMethod>() {
  return ::singa::PoolingProto_PoolMethod_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::Record_Type>() {
  return ::singa::Record_Type_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::UpdaterProto_ChangeProto>() {
  return ::singa::UpdaterProto_ChangeProto_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::MsgType>() {
  return ::singa::MsgType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::EntityType>() {
  return ::singa::EntityType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::Phase>() {
  return ::singa::Phase_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::ShareOption>() {
  return ::singa::ShareOption_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::PartitionType>() {
  return ::singa::PartitionType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::singa::ConnectionType>() {
  return ::singa::ConnectionType_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_model_2eproto__INCLUDED