// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: object_detection/protos/hyperparams.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fhyperparams_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fhyperparams_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#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 3009002 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_object_5fdetection_2fprotos_2fhyperparams_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[10]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto;
namespace object_detection {
namespace protos {
class BatchNorm;
class BatchNormDefaultTypeInternal;
extern BatchNormDefaultTypeInternal _BatchNorm_default_instance_;
class GroupNorm;
class GroupNormDefaultTypeInternal;
extern GroupNormDefaultTypeInternal _GroupNorm_default_instance_;
class Hyperparams;
class HyperparamsDefaultTypeInternal;
extern HyperparamsDefaultTypeInternal _Hyperparams_default_instance_;
class Initializer;
class InitializerDefaultTypeInternal;
extern InitializerDefaultTypeInternal _Initializer_default_instance_;
class L1Regularizer;
class L1RegularizerDefaultTypeInternal;
extern L1RegularizerDefaultTypeInternal _L1Regularizer_default_instance_;
class L2Regularizer;
class L2RegularizerDefaultTypeInternal;
extern L2RegularizerDefaultTypeInternal _L2Regularizer_default_instance_;
class RandomNormalInitializer;
class RandomNormalInitializerDefaultTypeInternal;
extern RandomNormalInitializerDefaultTypeInternal _RandomNormalInitializer_default_instance_;
class Regularizer;
class RegularizerDefaultTypeInternal;
extern RegularizerDefaultTypeInternal _Regularizer_default_instance_;
class TruncatedNormalInitializer;
class TruncatedNormalInitializerDefaultTypeInternal;
extern TruncatedNormalInitializerDefaultTypeInternal _TruncatedNormalInitializer_default_instance_;
class VarianceScalingInitializer;
class VarianceScalingInitializerDefaultTypeInternal;
extern VarianceScalingInitializerDefaultTypeInternal _VarianceScalingInitializer_default_instance_;
}  // namespace protos
}  // namespace object_detection
PROTOBUF_NAMESPACE_OPEN
template<> ::object_detection::protos::BatchNorm* Arena::CreateMaybeMessage<::object_detection::protos::BatchNorm>(Arena*);
template<> ::object_detection::protos::GroupNorm* Arena::CreateMaybeMessage<::object_detection::protos::GroupNorm>(Arena*);
template<> ::object_detection::protos::Hyperparams* Arena::CreateMaybeMessage<::object_detection::protos::Hyperparams>(Arena*);
template<> ::object_detection::protos::Initializer* Arena::CreateMaybeMessage<::object_detection::protos::Initializer>(Arena*);
template<> ::object_detection::protos::L1Regularizer* Arena::CreateMaybeMessage<::object_detection::protos::L1Regularizer>(Arena*);
template<> ::object_detection::protos::L2Regularizer* Arena::CreateMaybeMessage<::object_detection::protos::L2Regularizer>(Arena*);
template<> ::object_detection::protos::RandomNormalInitializer* Arena::CreateMaybeMessage<::object_detection::protos::RandomNormalInitializer>(Arena*);
template<> ::object_detection::protos::Regularizer* Arena::CreateMaybeMessage<::object_detection::protos::Regularizer>(Arena*);
template<> ::object_detection::protos::TruncatedNormalInitializer* Arena::CreateMaybeMessage<::object_detection::protos::TruncatedNormalInitializer>(Arena*);
template<> ::object_detection::protos::VarianceScalingInitializer* Arena::CreateMaybeMessage<::object_detection::protos::VarianceScalingInitializer>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace object_detection {
namespace protos {

enum Hyperparams_Op : int {
  Hyperparams_Op_CONV = 1,
  Hyperparams_Op_FC = 2
};
bool Hyperparams_Op_IsValid(int value);
constexpr Hyperparams_Op Hyperparams_Op_Op_MIN = Hyperparams_Op_CONV;
constexpr Hyperparams_Op Hyperparams_Op_Op_MAX = Hyperparams_Op_FC;
constexpr int Hyperparams_Op_Op_ARRAYSIZE = Hyperparams_Op_Op_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Hyperparams_Op_descriptor();
template<typename T>
inline const std::string& Hyperparams_Op_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Hyperparams_Op>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Hyperparams_Op_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Hyperparams_Op_descriptor(), enum_t_value);
}
inline bool Hyperparams_Op_Parse(
    const std::string& name, Hyperparams_Op* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Hyperparams_Op>(
    Hyperparams_Op_descriptor(), name, value);
}
enum Hyperparams_Activation : int {
  Hyperparams_Activation_NONE = 0,
  Hyperparams_Activation_RELU = 1,
  Hyperparams_Activation_RELU_6 = 2
};
bool Hyperparams_Activation_IsValid(int value);
constexpr Hyperparams_Activation Hyperparams_Activation_Activation_MIN = Hyperparams_Activation_NONE;
constexpr Hyperparams_Activation Hyperparams_Activation_Activation_MAX = Hyperparams_Activation_RELU_6;
constexpr int Hyperparams_Activation_Activation_ARRAYSIZE = Hyperparams_Activation_Activation_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Hyperparams_Activation_descriptor();
template<typename T>
inline const std::string& Hyperparams_Activation_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Hyperparams_Activation>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Hyperparams_Activation_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Hyperparams_Activation_descriptor(), enum_t_value);
}
inline bool Hyperparams_Activation_Parse(
    const std::string& name, Hyperparams_Activation* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Hyperparams_Activation>(
    Hyperparams_Activation_descriptor(), name, value);
}
enum VarianceScalingInitializer_Mode : int {
  VarianceScalingInitializer_Mode_FAN_IN = 0,
  VarianceScalingInitializer_Mode_FAN_OUT = 1,
  VarianceScalingInitializer_Mode_FAN_AVG = 2
};
bool VarianceScalingInitializer_Mode_IsValid(int value);
constexpr VarianceScalingInitializer_Mode VarianceScalingInitializer_Mode_Mode_MIN = VarianceScalingInitializer_Mode_FAN_IN;
constexpr VarianceScalingInitializer_Mode VarianceScalingInitializer_Mode_Mode_MAX = VarianceScalingInitializer_Mode_FAN_AVG;
constexpr int VarianceScalingInitializer_Mode_Mode_ARRAYSIZE = VarianceScalingInitializer_Mode_Mode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VarianceScalingInitializer_Mode_descriptor();
template<typename T>
inline const std::string& VarianceScalingInitializer_Mode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, VarianceScalingInitializer_Mode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function VarianceScalingInitializer_Mode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    VarianceScalingInitializer_Mode_descriptor(), enum_t_value);
}
inline bool VarianceScalingInitializer_Mode_Parse(
    const std::string& name, VarianceScalingInitializer_Mode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VarianceScalingInitializer_Mode>(
    VarianceScalingInitializer_Mode_descriptor(), name, value);
}
// ===================================================================

class Hyperparams :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.Hyperparams) */ {
 public:
  Hyperparams();
  virtual ~Hyperparams();

  Hyperparams(const Hyperparams& from);
  Hyperparams(Hyperparams&& from) noexcept
    : Hyperparams() {
    *this = ::std::move(from);
  }

  inline Hyperparams& operator=(const Hyperparams& from) {
    CopyFrom(from);
    return *this;
  }
  inline Hyperparams& operator=(Hyperparams&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Hyperparams& default_instance();

  enum NormalizerOneofCase {
    kBatchNorm = 5,
    kGroupNorm = 7,
    NORMALIZER_ONEOF_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Hyperparams* internal_default_instance() {
    return reinterpret_cast<const Hyperparams*>(
               &_Hyperparams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Hyperparams& a, Hyperparams& b) {
    a.Swap(&b);
  }
  inline void Swap(Hyperparams* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline Hyperparams* New() const final {
    return CreateMaybeMessage<Hyperparams>(nullptr);
  }

  Hyperparams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Hyperparams>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Hyperparams& from);
  void MergeFrom(const Hyperparams& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Hyperparams* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Hyperparams";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef Hyperparams_Op Op;
  static constexpr Op CONV =
    Hyperparams_Op_CONV;
  static constexpr Op FC =
    Hyperparams_Op_FC;
  static inline bool Op_IsValid(int value) {
    return Hyperparams_Op_IsValid(value);
  }
  static constexpr Op Op_MIN =
    Hyperparams_Op_Op_MIN;
  static constexpr Op Op_MAX =
    Hyperparams_Op_Op_MAX;
  static constexpr int Op_ARRAYSIZE =
    Hyperparams_Op_Op_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Op_descriptor() {
    return Hyperparams_Op_descriptor();
  }
  template<typename T>
  static inline const std::string& Op_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Op>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Op_Name.");
    return Hyperparams_Op_Name(enum_t_value);
  }
  static inline bool Op_Parse(const std::string& name,
      Op* value) {
    return Hyperparams_Op_Parse(name, value);
  }

  typedef Hyperparams_Activation Activation;
  static constexpr Activation NONE =
    Hyperparams_Activation_NONE;
  static constexpr Activation RELU =
    Hyperparams_Activation_RELU;
  static constexpr Activation RELU_6 =
    Hyperparams_Activation_RELU_6;
  static inline bool Activation_IsValid(int value) {
    return Hyperparams_Activation_IsValid(value);
  }
  static constexpr Activation Activation_MIN =
    Hyperparams_Activation_Activation_MIN;
  static constexpr Activation Activation_MAX =
    Hyperparams_Activation_Activation_MAX;
  static constexpr int Activation_ARRAYSIZE =
    Hyperparams_Activation_Activation_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Activation_descriptor() {
    return Hyperparams_Activation_descriptor();
  }
  template<typename T>
  static inline const std::string& Activation_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Activation>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Activation_Name.");
    return Hyperparams_Activation_Name(enum_t_value);
  }
  static inline bool Activation_Parse(const std::string& name,
      Activation* value) {
    return Hyperparams_Activation_Parse(name, value);
  }

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

  enum : int {
    kRegularizerFieldNumber = 2,
    kInitializerFieldNumber = 3,
    kRegularizeDepthwiseFieldNumber = 6,
    kOpFieldNumber = 1,
    kActivationFieldNumber = 4,
    kBatchNormFieldNumber = 5,
    kGroupNormFieldNumber = 7,
  };
  // optional .object_detection.protos.Regularizer regularizer = 2;
  bool has_regularizer() const;
  void clear_regularizer();
  const ::object_detection::protos::Regularizer& regularizer() const;
  ::object_detection::protos::Regularizer* release_regularizer();
  ::object_detection::protos::Regularizer* mutable_regularizer();
  void set_allocated_regularizer(::object_detection::protos::Regularizer* regularizer);

  // optional .object_detection.protos.Initializer initializer = 3;
  bool has_initializer() const;
  void clear_initializer();
  const ::object_detection::protos::Initializer& initializer() const;
  ::object_detection::protos::Initializer* release_initializer();
  ::object_detection::protos::Initializer* mutable_initializer();
  void set_allocated_initializer(::object_detection::protos::Initializer* initializer);

  // optional bool regularize_depthwise = 6 [default = false];
  bool has_regularize_depthwise() const;
  void clear_regularize_depthwise();
  bool regularize_depthwise() const;
  void set_regularize_depthwise(bool value);

  // optional .object_detection.protos.Hyperparams.Op op = 1 [default = CONV];
  bool has_op() const;
  void clear_op();
  ::object_detection::protos::Hyperparams_Op op() const;
  void set_op(::object_detection::protos::Hyperparams_Op value);

  // optional .object_detection.protos.Hyperparams.Activation activation = 4 [default = RELU];
  bool has_activation() const;
  void clear_activation();
  ::object_detection::protos::Hyperparams_Activation activation() const;
  void set_activation(::object_detection::protos::Hyperparams_Activation value);

  // optional .object_detection.protos.BatchNorm batch_norm = 5;
  bool has_batch_norm() const;
  void clear_batch_norm();
  const ::object_detection::protos::BatchNorm& batch_norm() const;
  ::object_detection::protos::BatchNorm* release_batch_norm();
  ::object_detection::protos::BatchNorm* mutable_batch_norm();
  void set_allocated_batch_norm(::object_detection::protos::BatchNorm* batch_norm);

  // optional .object_detection.protos.GroupNorm group_norm = 7;
  bool has_group_norm() const;
  void clear_group_norm();
  const ::object_detection::protos::GroupNorm& group_norm() const;
  ::object_detection::protos::GroupNorm* release_group_norm();
  ::object_detection::protos::GroupNorm* mutable_group_norm();
  void set_allocated_group_norm(::object_detection::protos::GroupNorm* group_norm);

  void clear_normalizer_oneof();
  NormalizerOneofCase normalizer_oneof_case() const;
  // @@protoc_insertion_point(class_scope:object_detection.protos.Hyperparams)
 private:
  class _Internal;
  void set_has_batch_norm();
  void set_has_group_norm();

  inline bool has_normalizer_oneof() const;
  inline void clear_has_normalizer_oneof();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::object_detection::protos::Regularizer* regularizer_;
  ::object_detection::protos::Initializer* initializer_;
  bool regularize_depthwise_;
  int op_;
  int activation_;
  union NormalizerOneofUnion {
    NormalizerOneofUnion() {}
    ::object_detection::protos::BatchNorm* batch_norm_;
    ::object_detection::protos::GroupNorm* group_norm_;
  } normalizer_oneof_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class Regularizer :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.Regularizer) */ {
 public:
  Regularizer();
  virtual ~Regularizer();

  Regularizer(const Regularizer& from);
  Regularizer(Regularizer&& from) noexcept
    : Regularizer() {
    *this = ::std::move(from);
  }

  inline Regularizer& operator=(const Regularizer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Regularizer& operator=(Regularizer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Regularizer& default_instance();

  enum RegularizerOneofCase {
    kL1Regularizer = 1,
    kL2Regularizer = 2,
    REGULARIZER_ONEOF_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Regularizer* internal_default_instance() {
    return reinterpret_cast<const Regularizer*>(
               &_Regularizer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Regularizer& a, Regularizer& b) {
    a.Swap(&b);
  }
  inline void Swap(Regularizer* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline Regularizer* New() const final {
    return CreateMaybeMessage<Regularizer>(nullptr);
  }

  Regularizer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Regularizer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Regularizer& from);
  void MergeFrom(const Regularizer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Regularizer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Regularizer";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kL1RegularizerFieldNumber = 1,
    kL2RegularizerFieldNumber = 2,
  };
  // optional .object_detection.protos.L1Regularizer l1_regularizer = 1;
  bool has_l1_regularizer() const;
  void clear_l1_regularizer();
  const ::object_detection::protos::L1Regularizer& l1_regularizer() const;
  ::object_detection::protos::L1Regularizer* release_l1_regularizer();
  ::object_detection::protos::L1Regularizer* mutable_l1_regularizer();
  void set_allocated_l1_regularizer(::object_detection::protos::L1Regularizer* l1_regularizer);

  // optional .object_detection.protos.L2Regularizer l2_regularizer = 2;
  bool has_l2_regularizer() const;
  void clear_l2_regularizer();
  const ::object_detection::protos::L2Regularizer& l2_regularizer() const;
  ::object_detection::protos::L2Regularizer* release_l2_regularizer();
  ::object_detection::protos::L2Regularizer* mutable_l2_regularizer();
  void set_allocated_l2_regularizer(::object_detection::protos::L2Regularizer* l2_regularizer);

  void clear_regularizer_oneof();
  RegularizerOneofCase regularizer_oneof_case() const;
  // @@protoc_insertion_point(class_scope:object_detection.protos.Regularizer)
 private:
  class _Internal;
  void set_has_l1_regularizer();
  void set_has_l2_regularizer();

  inline bool has_regularizer_oneof() const;
  inline void clear_has_regularizer_oneof();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  union RegularizerOneofUnion {
    RegularizerOneofUnion() {}
    ::object_detection::protos::L1Regularizer* l1_regularizer_;
    ::object_detection::protos::L2Regularizer* l2_regularizer_;
  } regularizer_oneof_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class L1Regularizer :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.L1Regularizer) */ {
 public:
  L1Regularizer();
  virtual ~L1Regularizer();

  L1Regularizer(const L1Regularizer& from);
  L1Regularizer(L1Regularizer&& from) noexcept
    : L1Regularizer() {
    *this = ::std::move(from);
  }

  inline L1Regularizer& operator=(const L1Regularizer& from) {
    CopyFrom(from);
    return *this;
  }
  inline L1Regularizer& operator=(L1Regularizer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const L1Regularizer& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const L1Regularizer* internal_default_instance() {
    return reinterpret_cast<const L1Regularizer*>(
               &_L1Regularizer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(L1Regularizer& a, L1Regularizer& b) {
    a.Swap(&b);
  }
  inline void Swap(L1Regularizer* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline L1Regularizer* New() const final {
    return CreateMaybeMessage<L1Regularizer>(nullptr);
  }

  L1Regularizer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<L1Regularizer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const L1Regularizer& from);
  void MergeFrom(const L1Regularizer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(L1Regularizer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.L1Regularizer";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWeightFieldNumber = 1,
  };
  // optional float weight = 1 [default = 1];
  bool has_weight() const;
  void clear_weight();
  float weight() const;
  void set_weight(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.L1Regularizer)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float weight_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class L2Regularizer :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.L2Regularizer) */ {
 public:
  L2Regularizer();
  virtual ~L2Regularizer();

  L2Regularizer(const L2Regularizer& from);
  L2Regularizer(L2Regularizer&& from) noexcept
    : L2Regularizer() {
    *this = ::std::move(from);
  }

  inline L2Regularizer& operator=(const L2Regularizer& from) {
    CopyFrom(from);
    return *this;
  }
  inline L2Regularizer& operator=(L2Regularizer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const L2Regularizer& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const L2Regularizer* internal_default_instance() {
    return reinterpret_cast<const L2Regularizer*>(
               &_L2Regularizer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(L2Regularizer& a, L2Regularizer& b) {
    a.Swap(&b);
  }
  inline void Swap(L2Regularizer* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline L2Regularizer* New() const final {
    return CreateMaybeMessage<L2Regularizer>(nullptr);
  }

  L2Regularizer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<L2Regularizer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const L2Regularizer& from);
  void MergeFrom(const L2Regularizer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(L2Regularizer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.L2Regularizer";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWeightFieldNumber = 1,
  };
  // optional float weight = 1 [default = 1];
  bool has_weight() const;
  void clear_weight();
  float weight() const;
  void set_weight(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.L2Regularizer)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float weight_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class Initializer :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.Initializer) */ {
 public:
  Initializer();
  virtual ~Initializer();

  Initializer(const Initializer& from);
  Initializer(Initializer&& from) noexcept
    : Initializer() {
    *this = ::std::move(from);
  }

  inline Initializer& operator=(const Initializer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Initializer& operator=(Initializer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Initializer& default_instance();

  enum InitializerOneofCase {
    kTruncatedNormalInitializer = 1,
    kVarianceScalingInitializer = 2,
    kRandomNormalInitializer = 3,
    INITIALIZER_ONEOF_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Initializer* internal_default_instance() {
    return reinterpret_cast<const Initializer*>(
               &_Initializer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Initializer& a, Initializer& b) {
    a.Swap(&b);
  }
  inline void Swap(Initializer* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline Initializer* New() const final {
    return CreateMaybeMessage<Initializer>(nullptr);
  }

  Initializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Initializer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Initializer& from);
  void MergeFrom(const Initializer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Initializer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Initializer";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTruncatedNormalInitializerFieldNumber = 1,
    kVarianceScalingInitializerFieldNumber = 2,
    kRandomNormalInitializerFieldNumber = 3,
  };
  // optional .object_detection.protos.TruncatedNormalInitializer truncated_normal_initializer = 1;
  bool has_truncated_normal_initializer() const;
  void clear_truncated_normal_initializer();
  const ::object_detection::protos::TruncatedNormalInitializer& truncated_normal_initializer() const;
  ::object_detection::protos::TruncatedNormalInitializer* release_truncated_normal_initializer();
  ::object_detection::protos::TruncatedNormalInitializer* mutable_truncated_normal_initializer();
  void set_allocated_truncated_normal_initializer(::object_detection::protos::TruncatedNormalInitializer* truncated_normal_initializer);

  // optional .object_detection.protos.VarianceScalingInitializer variance_scaling_initializer = 2;
  bool has_variance_scaling_initializer() const;
  void clear_variance_scaling_initializer();
  const ::object_detection::protos::VarianceScalingInitializer& variance_scaling_initializer() const;
  ::object_detection::protos::VarianceScalingInitializer* release_variance_scaling_initializer();
  ::object_detection::protos::VarianceScalingInitializer* mutable_variance_scaling_initializer();
  void set_allocated_variance_scaling_initializer(::object_detection::protos::VarianceScalingInitializer* variance_scaling_initializer);

  // optional .object_detection.protos.RandomNormalInitializer random_normal_initializer = 3;
  bool has_random_normal_initializer() const;
  void clear_random_normal_initializer();
  const ::object_detection::protos::RandomNormalInitializer& random_normal_initializer() const;
  ::object_detection::protos::RandomNormalInitializer* release_random_normal_initializer();
  ::object_detection::protos::RandomNormalInitializer* mutable_random_normal_initializer();
  void set_allocated_random_normal_initializer(::object_detection::protos::RandomNormalInitializer* random_normal_initializer);

  void clear_initializer_oneof();
  InitializerOneofCase initializer_oneof_case() const;
  // @@protoc_insertion_point(class_scope:object_detection.protos.Initializer)
 private:
  class _Internal;
  void set_has_truncated_normal_initializer();
  void set_has_variance_scaling_initializer();
  void set_has_random_normal_initializer();

  inline bool has_initializer_oneof() const;
  inline void clear_has_initializer_oneof();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  union InitializerOneofUnion {
    InitializerOneofUnion() {}
    ::object_detection::protos::TruncatedNormalInitializer* truncated_normal_initializer_;
    ::object_detection::protos::VarianceScalingInitializer* variance_scaling_initializer_;
    ::object_detection::protos::RandomNormalInitializer* random_normal_initializer_;
  } initializer_oneof_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class TruncatedNormalInitializer :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.TruncatedNormalInitializer) */ {
 public:
  TruncatedNormalInitializer();
  virtual ~TruncatedNormalInitializer();

  TruncatedNormalInitializer(const TruncatedNormalInitializer& from);
  TruncatedNormalInitializer(TruncatedNormalInitializer&& from) noexcept
    : TruncatedNormalInitializer() {
    *this = ::std::move(from);
  }

  inline TruncatedNormalInitializer& operator=(const TruncatedNormalInitializer& from) {
    CopyFrom(from);
    return *this;
  }
  inline TruncatedNormalInitializer& operator=(TruncatedNormalInitializer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TruncatedNormalInitializer& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TruncatedNormalInitializer* internal_default_instance() {
    return reinterpret_cast<const TruncatedNormalInitializer*>(
               &_TruncatedNormalInitializer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(TruncatedNormalInitializer& a, TruncatedNormalInitializer& b) {
    a.Swap(&b);
  }
  inline void Swap(TruncatedNormalInitializer* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline TruncatedNormalInitializer* New() const final {
    return CreateMaybeMessage<TruncatedNormalInitializer>(nullptr);
  }

  TruncatedNormalInitializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TruncatedNormalInitializer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TruncatedNormalInitializer& from);
  void MergeFrom(const TruncatedNormalInitializer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TruncatedNormalInitializer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.TruncatedNormalInitializer";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMeanFieldNumber = 1,
    kStddevFieldNumber = 2,
  };
  // optional float mean = 1 [default = 0];
  bool has_mean() const;
  void clear_mean();
  float mean() const;
  void set_mean(float value);

  // optional float stddev = 2 [default = 1];
  bool has_stddev() const;
  void clear_stddev();
  float stddev() const;
  void set_stddev(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.TruncatedNormalInitializer)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float mean_;
  float stddev_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class VarianceScalingInitializer :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.VarianceScalingInitializer) */ {
 public:
  VarianceScalingInitializer();
  virtual ~VarianceScalingInitializer();

  VarianceScalingInitializer(const VarianceScalingInitializer& from);
  VarianceScalingInitializer(VarianceScalingInitializer&& from) noexcept
    : VarianceScalingInitializer() {
    *this = ::std::move(from);
  }

  inline VarianceScalingInitializer& operator=(const VarianceScalingInitializer& from) {
    CopyFrom(from);
    return *this;
  }
  inline VarianceScalingInitializer& operator=(VarianceScalingInitializer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const VarianceScalingInitializer& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const VarianceScalingInitializer* internal_default_instance() {
    return reinterpret_cast<const VarianceScalingInitializer*>(
               &_VarianceScalingInitializer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(VarianceScalingInitializer& a, VarianceScalingInitializer& b) {
    a.Swap(&b);
  }
  inline void Swap(VarianceScalingInitializer* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline VarianceScalingInitializer* New() const final {
    return CreateMaybeMessage<VarianceScalingInitializer>(nullptr);
  }

  VarianceScalingInitializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VarianceScalingInitializer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const VarianceScalingInitializer& from);
  void MergeFrom(const VarianceScalingInitializer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VarianceScalingInitializer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.VarianceScalingInitializer";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef VarianceScalingInitializer_Mode Mode;
  static constexpr Mode FAN_IN =
    VarianceScalingInitializer_Mode_FAN_IN;
  static constexpr Mode FAN_OUT =
    VarianceScalingInitializer_Mode_FAN_OUT;
  static constexpr Mode FAN_AVG =
    VarianceScalingInitializer_Mode_FAN_AVG;
  static inline bool Mode_IsValid(int value) {
    return VarianceScalingInitializer_Mode_IsValid(value);
  }
  static constexpr Mode Mode_MIN =
    VarianceScalingInitializer_Mode_Mode_MIN;
  static constexpr Mode Mode_MAX =
    VarianceScalingInitializer_Mode_Mode_MAX;
  static constexpr int Mode_ARRAYSIZE =
    VarianceScalingInitializer_Mode_Mode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Mode_descriptor() {
    return VarianceScalingInitializer_Mode_descriptor();
  }
  template<typename T>
  static inline const std::string& Mode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Mode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Mode_Name.");
    return VarianceScalingInitializer_Mode_Name(enum_t_value);
  }
  static inline bool Mode_Parse(const std::string& name,
      Mode* value) {
    return VarianceScalingInitializer_Mode_Parse(name, value);
  }

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

  enum : int {
    kUniformFieldNumber = 2,
    kModeFieldNumber = 3,
    kFactorFieldNumber = 1,
  };
  // optional bool uniform = 2 [default = false];
  bool has_uniform() const;
  void clear_uniform();
  bool uniform() const;
  void set_uniform(bool value);

  // optional .object_detection.protos.VarianceScalingInitializer.Mode mode = 3 [default = FAN_IN];
  bool has_mode() const;
  void clear_mode();
  ::object_detection::protos::VarianceScalingInitializer_Mode mode() const;
  void set_mode(::object_detection::protos::VarianceScalingInitializer_Mode value);

  // optional float factor = 1 [default = 2];
  bool has_factor() const;
  void clear_factor();
  float factor() const;
  void set_factor(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.VarianceScalingInitializer)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool uniform_;
  int mode_;
  float factor_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class RandomNormalInitializer :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomNormalInitializer) */ {
 public:
  RandomNormalInitializer();
  virtual ~RandomNormalInitializer();

  RandomNormalInitializer(const RandomNormalInitializer& from);
  RandomNormalInitializer(RandomNormalInitializer&& from) noexcept
    : RandomNormalInitializer() {
    *this = ::std::move(from);
  }

  inline RandomNormalInitializer& operator=(const RandomNormalInitializer& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomNormalInitializer& operator=(RandomNormalInitializer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RandomNormalInitializer& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RandomNormalInitializer* internal_default_instance() {
    return reinterpret_cast<const RandomNormalInitializer*>(
               &_RandomNormalInitializer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(RandomNormalInitializer& a, RandomNormalInitializer& b) {
    a.Swap(&b);
  }
  inline void Swap(RandomNormalInitializer* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline RandomNormalInitializer* New() const final {
    return CreateMaybeMessage<RandomNormalInitializer>(nullptr);
  }

  RandomNormalInitializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RandomNormalInitializer>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RandomNormalInitializer& from);
  void MergeFrom(const RandomNormalInitializer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomNormalInitializer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomNormalInitializer";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMeanFieldNumber = 1,
    kStddevFieldNumber = 2,
  };
  // optional float mean = 1 [default = 0];
  bool has_mean() const;
  void clear_mean();
  float mean() const;
  void set_mean(float value);

  // optional float stddev = 2 [default = 1];
  bool has_stddev() const;
  void clear_stddev();
  float stddev() const;
  void set_stddev(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.RandomNormalInitializer)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float mean_;
  float stddev_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class BatchNorm :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.BatchNorm) */ {
 public:
  BatchNorm();
  virtual ~BatchNorm();

  BatchNorm(const BatchNorm& from);
  BatchNorm(BatchNorm&& from) noexcept
    : BatchNorm() {
    *this = ::std::move(from);
  }

  inline BatchNorm& operator=(const BatchNorm& from) {
    CopyFrom(from);
    return *this;
  }
  inline BatchNorm& operator=(BatchNorm&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BatchNorm& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BatchNorm* internal_default_instance() {
    return reinterpret_cast<const BatchNorm*>(
               &_BatchNorm_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(BatchNorm& a, BatchNorm& b) {
    a.Swap(&b);
  }
  inline void Swap(BatchNorm* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline BatchNorm* New() const final {
    return CreateMaybeMessage<BatchNorm>(nullptr);
  }

  BatchNorm* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BatchNorm>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BatchNorm& from);
  void MergeFrom(const BatchNorm& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BatchNorm* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.BatchNorm";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kScaleFieldNumber = 3,
    kEpsilonFieldNumber = 4,
    kDecayFieldNumber = 1,
    kCenterFieldNumber = 2,
    kTrainFieldNumber = 5,
  };
  // optional bool scale = 3 [default = false];
  bool has_scale() const;
  void clear_scale();
  bool scale() const;
  void set_scale(bool value);

  // optional float epsilon = 4 [default = 0.001];
  bool has_epsilon() const;
  void clear_epsilon();
  float epsilon() const;
  void set_epsilon(float value);

  // optional float decay = 1 [default = 0.999];
  bool has_decay() const;
  void clear_decay();
  float decay() const;
  void set_decay(float value);

  // optional bool center = 2 [default = true];
  bool has_center() const;
  void clear_center();
  bool center() const;
  void set_center(bool value);

  // optional bool train = 5 [default = true];
  bool has_train() const;
  void clear_train();
  bool train() const;
  void set_train(bool value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.BatchNorm)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool scale_;
  float epsilon_;
  float decay_;
  bool center_;
  bool train_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class GroupNorm :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.GroupNorm) */ {
 public:
  GroupNorm();
  virtual ~GroupNorm();

  GroupNorm(const GroupNorm& from);
  GroupNorm(GroupNorm&& from) noexcept
    : GroupNorm() {
    *this = ::std::move(from);
  }

  inline GroupNorm& operator=(const GroupNorm& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupNorm& operator=(GroupNorm&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GroupNorm& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GroupNorm* internal_default_instance() {
    return reinterpret_cast<const GroupNorm*>(
               &_GroupNorm_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(GroupNorm& a, GroupNorm& b) {
    a.Swap(&b);
  }
  inline void Swap(GroupNorm* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline GroupNorm* New() const final {
    return CreateMaybeMessage<GroupNorm>(nullptr);
  }

  GroupNorm* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GroupNorm>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GroupNorm& from);
  void MergeFrom(const GroupNorm& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GroupNorm* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.GroupNorm";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // @@protoc_insertion_point(class_scope:object_detection.protos.GroupNorm)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Hyperparams

// optional .object_detection.protos.Hyperparams.Op op = 1 [default = CONV];
inline bool Hyperparams::has_op() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Hyperparams::clear_op() {
  op_ = 1;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::object_detection::protos::Hyperparams_Op Hyperparams::op() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.op)
  return static_cast< ::object_detection::protos::Hyperparams_Op >(op_);
}
inline void Hyperparams::set_op(::object_detection::protos::Hyperparams_Op value) {
  assert(::object_detection::protos::Hyperparams_Op_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  op_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Hyperparams.op)
}

// optional .object_detection.protos.Regularizer regularizer = 2;
inline bool Hyperparams::has_regularizer() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Hyperparams::clear_regularizer() {
  if (regularizer_ != nullptr) regularizer_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::object_detection::protos::Regularizer& Hyperparams::regularizer() const {
  const ::object_detection::protos::Regularizer* p = regularizer_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.regularizer)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Regularizer*>(
      &::object_detection::protos::_Regularizer_default_instance_);
}
inline ::object_detection::protos::Regularizer* Hyperparams::release_regularizer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Hyperparams.regularizer)
  _has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::Regularizer* temp = regularizer_;
  regularizer_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Regularizer* Hyperparams::mutable_regularizer() {
  _has_bits_[0] |= 0x00000001u;
  if (regularizer_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Regularizer>(GetArenaNoVirtual());
    regularizer_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.regularizer)
  return regularizer_;
}
inline void Hyperparams::set_allocated_regularizer(::object_detection::protos::Regularizer* regularizer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete regularizer_;
  }
  if (regularizer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      regularizer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, regularizer, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  regularizer_ = regularizer;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Hyperparams.regularizer)
}

// optional .object_detection.protos.Initializer initializer = 3;
inline bool Hyperparams::has_initializer() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Hyperparams::clear_initializer() {
  if (initializer_ != nullptr) initializer_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::object_detection::protos::Initializer& Hyperparams::initializer() const {
  const ::object_detection::protos::Initializer* p = initializer_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.initializer)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Initializer*>(
      &::object_detection::protos::_Initializer_default_instance_);
}
inline ::object_detection::protos::Initializer* Hyperparams::release_initializer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Hyperparams.initializer)
  _has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::Initializer* temp = initializer_;
  initializer_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Initializer* Hyperparams::mutable_initializer() {
  _has_bits_[0] |= 0x00000002u;
  if (initializer_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Initializer>(GetArenaNoVirtual());
    initializer_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.initializer)
  return initializer_;
}
inline void Hyperparams::set_allocated_initializer(::object_detection::protos::Initializer* initializer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete initializer_;
  }
  if (initializer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      initializer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, initializer, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  initializer_ = initializer;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Hyperparams.initializer)
}

// optional .object_detection.protos.Hyperparams.Activation activation = 4 [default = RELU];
inline bool Hyperparams::has_activation() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Hyperparams::clear_activation() {
  activation_ = 1;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::object_detection::protos::Hyperparams_Activation Hyperparams::activation() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.activation)
  return static_cast< ::object_detection::protos::Hyperparams_Activation >(activation_);
}
inline void Hyperparams::set_activation(::object_detection::protos::Hyperparams_Activation value) {
  assert(::object_detection::protos::Hyperparams_Activation_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  activation_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Hyperparams.activation)
}

// optional .object_detection.protos.BatchNorm batch_norm = 5;
inline bool Hyperparams::has_batch_norm() const {
  return normalizer_oneof_case() == kBatchNorm;
}
inline void Hyperparams::set_has_batch_norm() {
  _oneof_case_[0] = kBatchNorm;
}
inline void Hyperparams::clear_batch_norm() {
  if (has_batch_norm()) {
    delete normalizer_oneof_.batch_norm_;
    clear_has_normalizer_oneof();
  }
}
inline ::object_detection::protos::BatchNorm* Hyperparams::release_batch_norm() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Hyperparams.batch_norm)
  if (has_batch_norm()) {
    clear_has_normalizer_oneof();
      ::object_detection::protos::BatchNorm* temp = normalizer_oneof_.batch_norm_;
    normalizer_oneof_.batch_norm_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::BatchNorm& Hyperparams::batch_norm() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.batch_norm)
  return has_batch_norm()
      ? *normalizer_oneof_.batch_norm_
      : *reinterpret_cast< ::object_detection::protos::BatchNorm*>(&::object_detection::protos::_BatchNorm_default_instance_);
}
inline ::object_detection::protos::BatchNorm* Hyperparams::mutable_batch_norm() {
  if (!has_batch_norm()) {
    clear_normalizer_oneof();
    set_has_batch_norm();
    normalizer_oneof_.batch_norm_ = CreateMaybeMessage< ::object_detection::protos::BatchNorm >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.batch_norm)
  return normalizer_oneof_.batch_norm_;
}

// optional .object_detection.protos.GroupNorm group_norm = 7;
inline bool Hyperparams::has_group_norm() const {
  return normalizer_oneof_case() == kGroupNorm;
}
inline void Hyperparams::set_has_group_norm() {
  _oneof_case_[0] = kGroupNorm;
}
inline void Hyperparams::clear_group_norm() {
  if (has_group_norm()) {
    delete normalizer_oneof_.group_norm_;
    clear_has_normalizer_oneof();
  }
}
inline ::object_detection::protos::GroupNorm* Hyperparams::release_group_norm() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Hyperparams.group_norm)
  if (has_group_norm()) {
    clear_has_normalizer_oneof();
      ::object_detection::protos::GroupNorm* temp = normalizer_oneof_.group_norm_;
    normalizer_oneof_.group_norm_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::GroupNorm& Hyperparams::group_norm() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.group_norm)
  return has_group_norm()
      ? *normalizer_oneof_.group_norm_
      : *reinterpret_cast< ::object_detection::protos::GroupNorm*>(&::object_detection::protos::_GroupNorm_default_instance_);
}
inline ::object_detection::protos::GroupNorm* Hyperparams::mutable_group_norm() {
  if (!has_group_norm()) {
    clear_normalizer_oneof();
    set_has_group_norm();
    normalizer_oneof_.group_norm_ = CreateMaybeMessage< ::object_detection::protos::GroupNorm >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.group_norm)
  return normalizer_oneof_.group_norm_;
}

// optional bool regularize_depthwise = 6 [default = false];
inline bool Hyperparams::has_regularize_depthwise() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Hyperparams::clear_regularize_depthwise() {
  regularize_depthwise_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool Hyperparams::regularize_depthwise() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.regularize_depthwise)
  return regularize_depthwise_;
}
inline void Hyperparams::set_regularize_depthwise(bool value) {
  _has_bits_[0] |= 0x00000004u;
  regularize_depthwise_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Hyperparams.regularize_depthwise)
}

inline bool Hyperparams::has_normalizer_oneof() const {
  return normalizer_oneof_case() != NORMALIZER_ONEOF_NOT_SET;
}
inline void Hyperparams::clear_has_normalizer_oneof() {
  _oneof_case_[0] = NORMALIZER_ONEOF_NOT_SET;
}
inline Hyperparams::NormalizerOneofCase Hyperparams::normalizer_oneof_case() const {
  return Hyperparams::NormalizerOneofCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Regularizer

// optional .object_detection.protos.L1Regularizer l1_regularizer = 1;
inline bool Regularizer::has_l1_regularizer() const {
  return regularizer_oneof_case() == kL1Regularizer;
}
inline void Regularizer::set_has_l1_regularizer() {
  _oneof_case_[0] = kL1Regularizer;
}
inline void Regularizer::clear_l1_regularizer() {
  if (has_l1_regularizer()) {
    delete regularizer_oneof_.l1_regularizer_;
    clear_has_regularizer_oneof();
  }
}
inline ::object_detection::protos::L1Regularizer* Regularizer::release_l1_regularizer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Regularizer.l1_regularizer)
  if (has_l1_regularizer()) {
    clear_has_regularizer_oneof();
      ::object_detection::protos::L1Regularizer* temp = regularizer_oneof_.l1_regularizer_;
    regularizer_oneof_.l1_regularizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::L1Regularizer& Regularizer::l1_regularizer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Regularizer.l1_regularizer)
  return has_l1_regularizer()
      ? *regularizer_oneof_.l1_regularizer_
      : *reinterpret_cast< ::object_detection::protos::L1Regularizer*>(&::object_detection::protos::_L1Regularizer_default_instance_);
}
inline ::object_detection::protos::L1Regularizer* Regularizer::mutable_l1_regularizer() {
  if (!has_l1_regularizer()) {
    clear_regularizer_oneof();
    set_has_l1_regularizer();
    regularizer_oneof_.l1_regularizer_ = CreateMaybeMessage< ::object_detection::protos::L1Regularizer >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Regularizer.l1_regularizer)
  return regularizer_oneof_.l1_regularizer_;
}

// optional .object_detection.protos.L2Regularizer l2_regularizer = 2;
inline bool Regularizer::has_l2_regularizer() const {
  return regularizer_oneof_case() == kL2Regularizer;
}
inline void Regularizer::set_has_l2_regularizer() {
  _oneof_case_[0] = kL2Regularizer;
}
inline void Regularizer::clear_l2_regularizer() {
  if (has_l2_regularizer()) {
    delete regularizer_oneof_.l2_regularizer_;
    clear_has_regularizer_oneof();
  }
}
inline ::object_detection::protos::L2Regularizer* Regularizer::release_l2_regularizer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Regularizer.l2_regularizer)
  if (has_l2_regularizer()) {
    clear_has_regularizer_oneof();
      ::object_detection::protos::L2Regularizer* temp = regularizer_oneof_.l2_regularizer_;
    regularizer_oneof_.l2_regularizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::L2Regularizer& Regularizer::l2_regularizer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Regularizer.l2_regularizer)
  return has_l2_regularizer()
      ? *regularizer_oneof_.l2_regularizer_
      : *reinterpret_cast< ::object_detection::protos::L2Regularizer*>(&::object_detection::protos::_L2Regularizer_default_instance_);
}
inline ::object_detection::protos::L2Regularizer* Regularizer::mutable_l2_regularizer() {
  if (!has_l2_regularizer()) {
    clear_regularizer_oneof();
    set_has_l2_regularizer();
    regularizer_oneof_.l2_regularizer_ = CreateMaybeMessage< ::object_detection::protos::L2Regularizer >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Regularizer.l2_regularizer)
  return regularizer_oneof_.l2_regularizer_;
}

inline bool Regularizer::has_regularizer_oneof() const {
  return regularizer_oneof_case() != REGULARIZER_ONEOF_NOT_SET;
}
inline void Regularizer::clear_has_regularizer_oneof() {
  _oneof_case_[0] = REGULARIZER_ONEOF_NOT_SET;
}
inline Regularizer::RegularizerOneofCase Regularizer::regularizer_oneof_case() const {
  return Regularizer::RegularizerOneofCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// L1Regularizer

// optional float weight = 1 [default = 1];
inline bool L1Regularizer::has_weight() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void L1Regularizer::clear_weight() {
  weight_ = 1;
  _has_bits_[0] &= ~0x00000001u;
}
inline float L1Regularizer::weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.L1Regularizer.weight)
  return weight_;
}
inline void L1Regularizer::set_weight(float value) {
  _has_bits_[0] |= 0x00000001u;
  weight_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.L1Regularizer.weight)
}

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

// L2Regularizer

// optional float weight = 1 [default = 1];
inline bool L2Regularizer::has_weight() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void L2Regularizer::clear_weight() {
  weight_ = 1;
  _has_bits_[0] &= ~0x00000001u;
}
inline float L2Regularizer::weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.L2Regularizer.weight)
  return weight_;
}
inline void L2Regularizer::set_weight(float value) {
  _has_bits_[0] |= 0x00000001u;
  weight_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.L2Regularizer.weight)
}

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

// Initializer

// optional .object_detection.protos.TruncatedNormalInitializer truncated_normal_initializer = 1;
inline bool Initializer::has_truncated_normal_initializer() const {
  return initializer_oneof_case() == kTruncatedNormalInitializer;
}
inline void Initializer::set_has_truncated_normal_initializer() {
  _oneof_case_[0] = kTruncatedNormalInitializer;
}
inline void Initializer::clear_truncated_normal_initializer() {
  if (has_truncated_normal_initializer()) {
    delete initializer_oneof_.truncated_normal_initializer_;
    clear_has_initializer_oneof();
  }
}
inline ::object_detection::protos::TruncatedNormalInitializer* Initializer::release_truncated_normal_initializer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Initializer.truncated_normal_initializer)
  if (has_truncated_normal_initializer()) {
    clear_has_initializer_oneof();
      ::object_detection::protos::TruncatedNormalInitializer* temp = initializer_oneof_.truncated_normal_initializer_;
    initializer_oneof_.truncated_normal_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::TruncatedNormalInitializer& Initializer::truncated_normal_initializer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Initializer.truncated_normal_initializer)
  return has_truncated_normal_initializer()
      ? *initializer_oneof_.truncated_normal_initializer_
      : *reinterpret_cast< ::object_detection::protos::TruncatedNormalInitializer*>(&::object_detection::protos::_TruncatedNormalInitializer_default_instance_);
}
inline ::object_detection::protos::TruncatedNormalInitializer* Initializer::mutable_truncated_normal_initializer() {
  if (!has_truncated_normal_initializer()) {
    clear_initializer_oneof();
    set_has_truncated_normal_initializer();
    initializer_oneof_.truncated_normal_initializer_ = CreateMaybeMessage< ::object_detection::protos::TruncatedNormalInitializer >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Initializer.truncated_normal_initializer)
  return initializer_oneof_.truncated_normal_initializer_;
}

// optional .object_detection.protos.VarianceScalingInitializer variance_scaling_initializer = 2;
inline bool Initializer::has_variance_scaling_initializer() const {
  return initializer_oneof_case() == kVarianceScalingInitializer;
}
inline void Initializer::set_has_variance_scaling_initializer() {
  _oneof_case_[0] = kVarianceScalingInitializer;
}
inline void Initializer::clear_variance_scaling_initializer() {
  if (has_variance_scaling_initializer()) {
    delete initializer_oneof_.variance_scaling_initializer_;
    clear_has_initializer_oneof();
  }
}
inline ::object_detection::protos::VarianceScalingInitializer* Initializer::release_variance_scaling_initializer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Initializer.variance_scaling_initializer)
  if (has_variance_scaling_initializer()) {
    clear_has_initializer_oneof();
      ::object_detection::protos::VarianceScalingInitializer* temp = initializer_oneof_.variance_scaling_initializer_;
    initializer_oneof_.variance_scaling_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::VarianceScalingInitializer& Initializer::variance_scaling_initializer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Initializer.variance_scaling_initializer)
  return has_variance_scaling_initializer()
      ? *initializer_oneof_.variance_scaling_initializer_
      : *reinterpret_cast< ::object_detection::protos::VarianceScalingInitializer*>(&::object_detection::protos::_VarianceScalingInitializer_default_instance_);
}
inline ::object_detection::protos::VarianceScalingInitializer* Initializer::mutable_variance_scaling_initializer() {
  if (!has_variance_scaling_initializer()) {
    clear_initializer_oneof();
    set_has_variance_scaling_initializer();
    initializer_oneof_.variance_scaling_initializer_ = CreateMaybeMessage< ::object_detection::protos::VarianceScalingInitializer >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Initializer.variance_scaling_initializer)
  return initializer_oneof_.variance_scaling_initializer_;
}

// optional .object_detection.protos.RandomNormalInitializer random_normal_initializer = 3;
inline bool Initializer::has_random_normal_initializer() const {
  return initializer_oneof_case() == kRandomNormalInitializer;
}
inline void Initializer::set_has_random_normal_initializer() {
  _oneof_case_[0] = kRandomNormalInitializer;
}
inline void Initializer::clear_random_normal_initializer() {
  if (has_random_normal_initializer()) {
    delete initializer_oneof_.random_normal_initializer_;
    clear_has_initializer_oneof();
  }
}
inline ::object_detection::protos::RandomNormalInitializer* Initializer::release_random_normal_initializer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Initializer.random_normal_initializer)
  if (has_random_normal_initializer()) {
    clear_has_initializer_oneof();
      ::object_detection::protos::RandomNormalInitializer* temp = initializer_oneof_.random_normal_initializer_;
    initializer_oneof_.random_normal_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomNormalInitializer& Initializer::random_normal_initializer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Initializer.random_normal_initializer)
  return has_random_normal_initializer()
      ? *initializer_oneof_.random_normal_initializer_
      : *reinterpret_cast< ::object_detection::protos::RandomNormalInitializer*>(&::object_detection::protos::_RandomNormalInitializer_default_instance_);
}
inline ::object_detection::protos::RandomNormalInitializer* Initializer::mutable_random_normal_initializer() {
  if (!has_random_normal_initializer()) {
    clear_initializer_oneof();
    set_has_random_normal_initializer();
    initializer_oneof_.random_normal_initializer_ = CreateMaybeMessage< ::object_detection::protos::RandomNormalInitializer >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Initializer.random_normal_initializer)
  return initializer_oneof_.random_normal_initializer_;
}

inline bool Initializer::has_initializer_oneof() const {
  return initializer_oneof_case() != INITIALIZER_ONEOF_NOT_SET;
}
inline void Initializer::clear_has_initializer_oneof() {
  _oneof_case_[0] = INITIALIZER_ONEOF_NOT_SET;
}
inline Initializer::InitializerOneofCase Initializer::initializer_oneof_case() const {
  return Initializer::InitializerOneofCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TruncatedNormalInitializer

// optional float mean = 1 [default = 0];
inline bool TruncatedNormalInitializer::has_mean() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TruncatedNormalInitializer::clear_mean() {
  mean_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline float TruncatedNormalInitializer::mean() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.TruncatedNormalInitializer.mean)
  return mean_;
}
inline void TruncatedNormalInitializer::set_mean(float value) {
  _has_bits_[0] |= 0x00000001u;
  mean_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.TruncatedNormalInitializer.mean)
}

// optional float stddev = 2 [default = 1];
inline bool TruncatedNormalInitializer::has_stddev() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TruncatedNormalInitializer::clear_stddev() {
  stddev_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline float TruncatedNormalInitializer::stddev() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.TruncatedNormalInitializer.stddev)
  return stddev_;
}
inline void TruncatedNormalInitializer::set_stddev(float value) {
  _has_bits_[0] |= 0x00000002u;
  stddev_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.TruncatedNormalInitializer.stddev)
}

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

// VarianceScalingInitializer

// optional float factor = 1 [default = 2];
inline bool VarianceScalingInitializer::has_factor() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void VarianceScalingInitializer::clear_factor() {
  factor_ = 2;
  _has_bits_[0] &= ~0x00000004u;
}
inline float VarianceScalingInitializer::factor() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.VarianceScalingInitializer.factor)
  return factor_;
}
inline void VarianceScalingInitializer::set_factor(float value) {
  _has_bits_[0] |= 0x00000004u;
  factor_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.VarianceScalingInitializer.factor)
}

// optional bool uniform = 2 [default = false];
inline bool VarianceScalingInitializer::has_uniform() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VarianceScalingInitializer::clear_uniform() {
  uniform_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool VarianceScalingInitializer::uniform() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.VarianceScalingInitializer.uniform)
  return uniform_;
}
inline void VarianceScalingInitializer::set_uniform(bool value) {
  _has_bits_[0] |= 0x00000001u;
  uniform_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.VarianceScalingInitializer.uniform)
}

// optional .object_detection.protos.VarianceScalingInitializer.Mode mode = 3 [default = FAN_IN];
inline bool VarianceScalingInitializer::has_mode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VarianceScalingInitializer::clear_mode() {
  mode_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::object_detection::protos::VarianceScalingInitializer_Mode VarianceScalingInitializer::mode() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.VarianceScalingInitializer.mode)
  return static_cast< ::object_detection::protos::VarianceScalingInitializer_Mode >(mode_);
}
inline void VarianceScalingInitializer::set_mode(::object_detection::protos::VarianceScalingInitializer_Mode value) {
  assert(::object_detection::protos::VarianceScalingInitializer_Mode_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  mode_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.VarianceScalingInitializer.mode)
}

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

// RandomNormalInitializer

// optional float mean = 1 [default = 0];
inline bool RandomNormalInitializer::has_mean() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RandomNormalInitializer::clear_mean() {
  mean_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline float RandomNormalInitializer::mean() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomNormalInitializer.mean)
  return mean_;
}
inline void RandomNormalInitializer::set_mean(float value) {
  _has_bits_[0] |= 0x00000001u;
  mean_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomNormalInitializer.mean)
}

// optional float stddev = 2 [default = 1];
inline bool RandomNormalInitializer::has_stddev() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RandomNormalInitializer::clear_stddev() {
  stddev_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline float RandomNormalInitializer::stddev() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomNormalInitializer.stddev)
  return stddev_;
}
inline void RandomNormalInitializer::set_stddev(float value) {
  _has_bits_[0] |= 0x00000002u;
  stddev_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomNormalInitializer.stddev)
}

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

// BatchNorm

// optional float decay = 1 [default = 0.999];
inline bool BatchNorm::has_decay() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BatchNorm::clear_decay() {
  decay_ = 0.999f;
  _has_bits_[0] &= ~0x00000004u;
}
inline float BatchNorm::decay() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BatchNorm.decay)
  return decay_;
}
inline void BatchNorm::set_decay(float value) {
  _has_bits_[0] |= 0x00000004u;
  decay_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BatchNorm.decay)
}

// optional bool center = 2 [default = true];
inline bool BatchNorm::has_center() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BatchNorm::clear_center() {
  center_ = true;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool BatchNorm::center() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BatchNorm.center)
  return center_;
}
inline void BatchNorm::set_center(bool value) {
  _has_bits_[0] |= 0x00000008u;
  center_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BatchNorm.center)
}

// optional bool scale = 3 [default = false];
inline bool BatchNorm::has_scale() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BatchNorm::clear_scale() {
  scale_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool BatchNorm::scale() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BatchNorm.scale)
  return scale_;
}
inline void BatchNorm::set_scale(bool value) {
  _has_bits_[0] |= 0x00000001u;
  scale_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BatchNorm.scale)
}

// optional float epsilon = 4 [default = 0.001];
inline bool BatchNorm::has_epsilon() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BatchNorm::clear_epsilon() {
  epsilon_ = 0.001f;
  _has_bits_[0] &= ~0x00000002u;
}
inline float BatchNorm::epsilon() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BatchNorm.epsilon)
  return epsilon_;
}
inline void BatchNorm::set_epsilon(float value) {
  _has_bits_[0] |= 0x00000002u;
  epsilon_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BatchNorm.epsilon)
}

// optional bool train = 5 [default = true];
inline bool BatchNorm::has_train() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BatchNorm::clear_train() {
  train_ = true;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool BatchNorm::train() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BatchNorm.train)
  return train_;
}
inline void BatchNorm::set_train(bool value) {
  _has_bits_[0] |= 0x00000010u;
  train_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BatchNorm.train)
}

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

// GroupNorm

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace object_detection

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::object_detection::protos::Hyperparams_Op> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::object_detection::protos::Hyperparams_Op>() {
  return ::object_detection::protos::Hyperparams_Op_descriptor();
}
template <> struct is_proto_enum< ::object_detection::protos::Hyperparams_Activation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::object_detection::protos::Hyperparams_Activation>() {
  return ::object_detection::protos::Hyperparams_Activation_descriptor();
}
template <> struct is_proto_enum< ::object_detection::protos::VarianceScalingInitializer_Mode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::object_detection::protos::VarianceScalingInitializer_Mode>() {
  return ::object_detection::protos::VarianceScalingInitializer_Mode_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fhyperparams_2eproto
