// 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 < 3021000
#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 3021005 < 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_bases.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.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 uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_object_5fdetection_2fprotos_2fhyperparams_2eproto;
namespace object_detection {
namespace protos {
class BatchNorm;
struct BatchNormDefaultTypeInternal;
extern BatchNormDefaultTypeInternal _BatchNorm_default_instance_;
class GroupNorm;
struct GroupNormDefaultTypeInternal;
extern GroupNormDefaultTypeInternal _GroupNorm_default_instance_;
class Hyperparams;
struct HyperparamsDefaultTypeInternal;
extern HyperparamsDefaultTypeInternal _Hyperparams_default_instance_;
class Initializer;
struct InitializerDefaultTypeInternal;
extern InitializerDefaultTypeInternal _Initializer_default_instance_;
class L1Regularizer;
struct L1RegularizerDefaultTypeInternal;
extern L1RegularizerDefaultTypeInternal _L1Regularizer_default_instance_;
class L2Regularizer;
struct L2RegularizerDefaultTypeInternal;
extern L2RegularizerDefaultTypeInternal _L2Regularizer_default_instance_;
class RandomNormalInitializer;
struct RandomNormalInitializerDefaultTypeInternal;
extern RandomNormalInitializerDefaultTypeInternal _RandomNormalInitializer_default_instance_;
class Regularizer;
struct RegularizerDefaultTypeInternal;
extern RegularizerDefaultTypeInternal _Regularizer_default_instance_;
class TruncatedNormalInitializer;
struct TruncatedNormalInitializerDefaultTypeInternal;
extern TruncatedNormalInitializerDefaultTypeInternal _TruncatedNormalInitializer_default_instance_;
class VarianceScalingInitializer;
struct 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VarianceScalingInitializer_Mode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VarianceScalingInitializer_Mode>(
    VarianceScalingInitializer_Mode_descriptor(), name, value);
}
// ===================================================================

class Hyperparams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.Hyperparams) */ {
 public:
  inline Hyperparams() : Hyperparams(nullptr) {}
  ~Hyperparams() override;
  explicit PROTOBUF_CONSTEXPR Hyperparams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Hyperparams& default_instance() {
    return *internal_default_instance();
  }
  enum NormalizerOneofCase {
    kBatchNorm = 5,
    kGroupNorm = 7,
    NORMALIZER_ONEOF_NOT_SET = 0,
  };

  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Hyperparams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Hyperparams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Hyperparams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Hyperparams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Hyperparams& from) {
    Hyperparams::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Hyperparams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Hyperparams";
  }
  protected:
  explicit Hyperparams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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;
  private:
  bool _internal_has_regularizer() const;
  public:
  void clear_regularizer();
  const ::object_detection::protos::Regularizer& regularizer() const;
  PROTOBUF_NODISCARD ::object_detection::protos::Regularizer* release_regularizer();
  ::object_detection::protos::Regularizer* mutable_regularizer();
  void set_allocated_regularizer(::object_detection::protos::Regularizer* regularizer);
  private:
  const ::object_detection::protos::Regularizer& _internal_regularizer() const;
  ::object_detection::protos::Regularizer* _internal_mutable_regularizer();
  public:
  void unsafe_arena_set_allocated_regularizer(
      ::object_detection::protos::Regularizer* regularizer);
  ::object_detection::protos::Regularizer* unsafe_arena_release_regularizer();

  // optional .object_detection.protos.Initializer initializer = 3;
  bool has_initializer() const;
  private:
  bool _internal_has_initializer() const;
  public:
  void clear_initializer();
  const ::object_detection::protos::Initializer& initializer() const;
  PROTOBUF_NODISCARD ::object_detection::protos::Initializer* release_initializer();
  ::object_detection::protos::Initializer* mutable_initializer();
  void set_allocated_initializer(::object_detection::protos::Initializer* initializer);
  private:
  const ::object_detection::protos::Initializer& _internal_initializer() const;
  ::object_detection::protos::Initializer* _internal_mutable_initializer();
  public:
  void unsafe_arena_set_allocated_initializer(
      ::object_detection::protos::Initializer* initializer);
  ::object_detection::protos::Initializer* unsafe_arena_release_initializer();

  // optional bool regularize_depthwise = 6 [default = false];
  bool has_regularize_depthwise() const;
  private:
  bool _internal_has_regularize_depthwise() const;
  public:
  void clear_regularize_depthwise();
  bool regularize_depthwise() const;
  void set_regularize_depthwise(bool value);
  private:
  bool _internal_regularize_depthwise() const;
  void _internal_set_regularize_depthwise(bool value);
  public:

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

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

  // .object_detection.protos.BatchNorm batch_norm = 5;
  bool has_batch_norm() const;
  private:
  bool _internal_has_batch_norm() const;
  public:
  void clear_batch_norm();
  const ::object_detection::protos::BatchNorm& batch_norm() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::BatchNorm& _internal_batch_norm() const;
  ::object_detection::protos::BatchNorm* _internal_mutable_batch_norm();
  public:
  void unsafe_arena_set_allocated_batch_norm(
      ::object_detection::protos::BatchNorm* batch_norm);
  ::object_detection::protos::BatchNorm* unsafe_arena_release_batch_norm();

  // .object_detection.protos.GroupNorm group_norm = 7;
  bool has_group_norm() const;
  private:
  bool _internal_has_group_norm() const;
  public:
  void clear_group_norm();
  const ::object_detection::protos::GroupNorm& group_norm() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::GroupNorm& _internal_group_norm() const;
  ::object_detection::protos::GroupNorm* _internal_mutable_group_norm();
  public:
  void unsafe_arena_set_allocated_group_norm(
      ::object_detection::protos::GroupNorm* group_norm);
  ::object_detection::protos::GroupNorm* unsafe_arena_release_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();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::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 {
      constexpr NormalizerOneofUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::object_detection::protos::BatchNorm* batch_norm_;
      ::object_detection::protos::GroupNorm* group_norm_;
    } normalizer_oneof_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class Regularizer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.Regularizer) */ {
 public:
  inline Regularizer() : Regularizer(nullptr) {}
  ~Regularizer() override;
  explicit PROTOBUF_CONSTEXPR Regularizer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Regularizer& default_instance() {
    return *internal_default_instance();
  }
  enum RegularizerOneofCase {
    kL1Regularizer = 1,
    kL2Regularizer = 2,
    REGULARIZER_ONEOF_NOT_SET = 0,
  };

  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Regularizer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Regularizer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Regularizer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Regularizer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Regularizer& from) {
    Regularizer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Regularizer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Regularizer";
  }
  protected:
  explicit Regularizer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kL1RegularizerFieldNumber = 1,
    kL2RegularizerFieldNumber = 2,
  };
  // .object_detection.protos.L1Regularizer l1_regularizer = 1;
  bool has_l1_regularizer() const;
  private:
  bool _internal_has_l1_regularizer() const;
  public:
  void clear_l1_regularizer();
  const ::object_detection::protos::L1Regularizer& l1_regularizer() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::L1Regularizer& _internal_l1_regularizer() const;
  ::object_detection::protos::L1Regularizer* _internal_mutable_l1_regularizer();
  public:
  void unsafe_arena_set_allocated_l1_regularizer(
      ::object_detection::protos::L1Regularizer* l1_regularizer);
  ::object_detection::protos::L1Regularizer* unsafe_arena_release_l1_regularizer();

  // .object_detection.protos.L2Regularizer l2_regularizer = 2;
  bool has_l2_regularizer() const;
  private:
  bool _internal_has_l2_regularizer() const;
  public:
  void clear_l2_regularizer();
  const ::object_detection::protos::L2Regularizer& l2_regularizer() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::L2Regularizer& _internal_l2_regularizer() const;
  ::object_detection::protos::L2Regularizer* _internal_mutable_l2_regularizer();
  public:
  void unsafe_arena_set_allocated_l2_regularizer(
      ::object_detection::protos::L2Regularizer* l2_regularizer);
  ::object_detection::protos::L2Regularizer* unsafe_arena_release_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();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union RegularizerOneofUnion {
      constexpr RegularizerOneofUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::object_detection::protos::L1Regularizer* l1_regularizer_;
      ::object_detection::protos::L2Regularizer* l2_regularizer_;
    } regularizer_oneof_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class L1Regularizer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.L1Regularizer) */ {
 public:
  inline L1Regularizer() : L1Regularizer(nullptr) {}
  ~L1Regularizer() override;
  explicit PROTOBUF_CONSTEXPR L1Regularizer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const L1Regularizer& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(L1Regularizer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  L1Regularizer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<L1Regularizer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const L1Regularizer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const L1Regularizer& from) {
    L1Regularizer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(L1Regularizer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.L1Regularizer";
  }
  protected:
  explicit L1Regularizer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

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

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float weight_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class L2Regularizer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.L2Regularizer) */ {
 public:
  inline L2Regularizer() : L2Regularizer(nullptr) {}
  ~L2Regularizer() override;
  explicit PROTOBUF_CONSTEXPR L2Regularizer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const L2Regularizer& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(L2Regularizer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  L2Regularizer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<L2Regularizer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const L2Regularizer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const L2Regularizer& from) {
    L2Regularizer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(L2Regularizer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.L2Regularizer";
  }
  protected:
  explicit L2Regularizer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

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

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float weight_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class Initializer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.Initializer) */ {
 public:
  inline Initializer() : Initializer(nullptr) {}
  ~Initializer() override;
  explicit PROTOBUF_CONSTEXPR Initializer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Initializer& default_instance() {
    return *internal_default_instance();
  }
  enum InitializerOneofCase {
    kTruncatedNormalInitializer = 1,
    kVarianceScalingInitializer = 2,
    kRandomNormalInitializer = 3,
    INITIALIZER_ONEOF_NOT_SET = 0,
  };

  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Initializer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Initializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Initializer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Initializer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Initializer& from) {
    Initializer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Initializer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Initializer";
  }
  protected:
  explicit Initializer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTruncatedNormalInitializerFieldNumber = 1,
    kVarianceScalingInitializerFieldNumber = 2,
    kRandomNormalInitializerFieldNumber = 3,
  };
  // .object_detection.protos.TruncatedNormalInitializer truncated_normal_initializer = 1;
  bool has_truncated_normal_initializer() const;
  private:
  bool _internal_has_truncated_normal_initializer() const;
  public:
  void clear_truncated_normal_initializer();
  const ::object_detection::protos::TruncatedNormalInitializer& truncated_normal_initializer() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::TruncatedNormalInitializer& _internal_truncated_normal_initializer() const;
  ::object_detection::protos::TruncatedNormalInitializer* _internal_mutable_truncated_normal_initializer();
  public:
  void unsafe_arena_set_allocated_truncated_normal_initializer(
      ::object_detection::protos::TruncatedNormalInitializer* truncated_normal_initializer);
  ::object_detection::protos::TruncatedNormalInitializer* unsafe_arena_release_truncated_normal_initializer();

  // .object_detection.protos.VarianceScalingInitializer variance_scaling_initializer = 2;
  bool has_variance_scaling_initializer() const;
  private:
  bool _internal_has_variance_scaling_initializer() const;
  public:
  void clear_variance_scaling_initializer();
  const ::object_detection::protos::VarianceScalingInitializer& variance_scaling_initializer() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::VarianceScalingInitializer& _internal_variance_scaling_initializer() const;
  ::object_detection::protos::VarianceScalingInitializer* _internal_mutable_variance_scaling_initializer();
  public:
  void unsafe_arena_set_allocated_variance_scaling_initializer(
      ::object_detection::protos::VarianceScalingInitializer* variance_scaling_initializer);
  ::object_detection::protos::VarianceScalingInitializer* unsafe_arena_release_variance_scaling_initializer();

  // .object_detection.protos.RandomNormalInitializer random_normal_initializer = 3;
  bool has_random_normal_initializer() const;
  private:
  bool _internal_has_random_normal_initializer() const;
  public:
  void clear_random_normal_initializer();
  const ::object_detection::protos::RandomNormalInitializer& random_normal_initializer() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::RandomNormalInitializer& _internal_random_normal_initializer() const;
  ::object_detection::protos::RandomNormalInitializer* _internal_mutable_random_normal_initializer();
  public:
  void unsafe_arena_set_allocated_random_normal_initializer(
      ::object_detection::protos::RandomNormalInitializer* random_normal_initializer);
  ::object_detection::protos::RandomNormalInitializer* unsafe_arena_release_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();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union InitializerOneofUnion {
      constexpr InitializerOneofUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::object_detection::protos::TruncatedNormalInitializer* truncated_normal_initializer_;
      ::object_detection::protos::VarianceScalingInitializer* variance_scaling_initializer_;
      ::object_detection::protos::RandomNormalInitializer* random_normal_initializer_;
    } initializer_oneof_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class TruncatedNormalInitializer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.TruncatedNormalInitializer) */ {
 public:
  inline TruncatedNormalInitializer() : TruncatedNormalInitializer(nullptr) {}
  ~TruncatedNormalInitializer() override;
  explicit PROTOBUF_CONSTEXPR TruncatedNormalInitializer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TruncatedNormalInitializer& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TruncatedNormalInitializer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TruncatedNormalInitializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TruncatedNormalInitializer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TruncatedNormalInitializer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TruncatedNormalInitializer& from) {
    TruncatedNormalInitializer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TruncatedNormalInitializer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.TruncatedNormalInitializer";
  }
  protected:
  explicit TruncatedNormalInitializer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

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

  // optional float stddev = 2 [default = 1];
  bool has_stddev() const;
  private:
  bool _internal_has_stddev() const;
  public:
  void clear_stddev();
  float stddev() const;
  void set_stddev(float value);
  private:
  float _internal_stddev() const;
  void _internal_set_stddev(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float mean_;
    float stddev_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class VarianceScalingInitializer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.VarianceScalingInitializer) */ {
 public:
  inline VarianceScalingInitializer() : VarianceScalingInitializer(nullptr) {}
  ~VarianceScalingInitializer() override;
  explicit PROTOBUF_CONSTEXPR VarianceScalingInitializer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VarianceScalingInitializer& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VarianceScalingInitializer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  VarianceScalingInitializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VarianceScalingInitializer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VarianceScalingInitializer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const VarianceScalingInitializer& from) {
    VarianceScalingInitializer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VarianceScalingInitializer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.VarianceScalingInitializer";
  }
  protected:
  explicit VarianceScalingInitializer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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;
  private:
  bool _internal_has_uniform() const;
  public:
  void clear_uniform();
  bool uniform() const;
  void set_uniform(bool value);
  private:
  bool _internal_uniform() const;
  void _internal_set_uniform(bool value);
  public:

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

  // optional float factor = 1 [default = 2];
  bool has_factor() const;
  private:
  bool _internal_has_factor() const;
  public:
  void clear_factor();
  float factor() const;
  void set_factor(float value);
  private:
  float _internal_factor() const;
  void _internal_set_factor(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool uniform_;
    int mode_;
    float factor_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class RandomNormalInitializer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.RandomNormalInitializer) */ {
 public:
  inline RandomNormalInitializer() : RandomNormalInitializer(nullptr) {}
  ~RandomNormalInitializer() override;
  explicit PROTOBUF_CONSTEXPR RandomNormalInitializer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RandomNormalInitializer& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RandomNormalInitializer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RandomNormalInitializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RandomNormalInitializer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RandomNormalInitializer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RandomNormalInitializer& from) {
    RandomNormalInitializer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RandomNormalInitializer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomNormalInitializer";
  }
  protected:
  explicit RandomNormalInitializer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

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

  // optional float stddev = 2 [default = 1];
  bool has_stddev() const;
  private:
  bool _internal_has_stddev() const;
  public:
  void clear_stddev();
  float stddev() const;
  void set_stddev(float value);
  private:
  float _internal_stddev() const;
  void _internal_set_stddev(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float mean_;
    float stddev_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class BatchNorm final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.BatchNorm) */ {
 public:
  inline BatchNorm() : BatchNorm(nullptr) {}
  ~BatchNorm() override;
  explicit PROTOBUF_CONSTEXPR BatchNorm(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BatchNorm& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BatchNorm* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BatchNorm* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BatchNorm>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BatchNorm& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BatchNorm& from) {
    BatchNorm::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BatchNorm* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.BatchNorm";
  }
  protected:
  explicit BatchNorm(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // 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;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  bool scale() const;
  void set_scale(bool value);
  private:
  bool _internal_scale() const;
  void _internal_set_scale(bool value);
  public:

  // optional float epsilon = 4 [default = 0.001];
  bool has_epsilon() const;
  private:
  bool _internal_has_epsilon() const;
  public:
  void clear_epsilon();
  float epsilon() const;
  void set_epsilon(float value);
  private:
  float _internal_epsilon() const;
  void _internal_set_epsilon(float value);
  public:

  // optional float decay = 1 [default = 0.999];
  bool has_decay() const;
  private:
  bool _internal_has_decay() const;
  public:
  void clear_decay();
  float decay() const;
  void set_decay(float value);
  private:
  float _internal_decay() const;
  void _internal_set_decay(float value);
  public:

  // optional bool center = 2 [default = true];
  bool has_center() const;
  private:
  bool _internal_has_center() const;
  public:
  void clear_center();
  bool center() const;
  void set_center(bool value);
  private:
  bool _internal_center() const;
  void _internal_set_center(bool value);
  public:

  // optional bool train = 5 [default = true];
  bool has_train() const;
  private:
  bool _internal_has_train() const;
  public:
  void clear_train();
  bool train() const;
  void set_train(bool value);
  private:
  bool _internal_train() const;
  void _internal_set_train(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::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_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fhyperparams_2eproto;
};
// -------------------------------------------------------------------

class GroupNorm final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:object_detection.protos.GroupNorm) */ {
 public:
  inline GroupNorm() : GroupNorm(nullptr) {}
  explicit PROTOBUF_CONSTEXPR GroupNorm(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GroupNorm& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GroupNorm* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GroupNorm* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupNorm>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const GroupNorm& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const GroupNorm& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.GroupNorm";
  }
  protected:
  explicit GroupNorm(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  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::_internal_has_op() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Hyperparams::has_op() const {
  return _internal_has_op();
}
inline void Hyperparams::clear_op() {
  _impl_.op_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::object_detection::protos::Hyperparams_Op Hyperparams::_internal_op() const {
  return static_cast< ::object_detection::protos::Hyperparams_Op >(_impl_.op_);
}
inline ::object_detection::protos::Hyperparams_Op Hyperparams::op() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.op)
  return _internal_op();
}
inline void Hyperparams::_internal_set_op(::object_detection::protos::Hyperparams_Op value) {
  assert(::object_detection::protos::Hyperparams_Op_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.op_ = value;
}
inline void Hyperparams::set_op(::object_detection::protos::Hyperparams_Op value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Hyperparams.op)
}

// optional .object_detection.protos.Regularizer regularizer = 2;
inline bool Hyperparams::_internal_has_regularizer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.regularizer_ != nullptr);
  return value;
}
inline bool Hyperparams::has_regularizer() const {
  return _internal_has_regularizer();
}
inline void Hyperparams::clear_regularizer() {
  if (_impl_.regularizer_ != nullptr) _impl_.regularizer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::object_detection::protos::Regularizer& Hyperparams::_internal_regularizer() const {
  const ::object_detection::protos::Regularizer* p = _impl_.regularizer_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Regularizer&>(
      ::object_detection::protos::_Regularizer_default_instance_);
}
inline const ::object_detection::protos::Regularizer& Hyperparams::regularizer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.regularizer)
  return _internal_regularizer();
}
inline void Hyperparams::unsafe_arena_set_allocated_regularizer(
    ::object_detection::protos::Regularizer* regularizer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.regularizer_);
  }
  _impl_.regularizer_ = regularizer;
  if (regularizer) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Hyperparams.regularizer)
}
inline ::object_detection::protos::Regularizer* Hyperparams::release_regularizer() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::Regularizer* temp = _impl_.regularizer_;
  _impl_.regularizer_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::object_detection::protos::Regularizer* Hyperparams::unsafe_arena_release_regularizer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Hyperparams.regularizer)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::Regularizer* temp = _impl_.regularizer_;
  _impl_.regularizer_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Regularizer* Hyperparams::_internal_mutable_regularizer() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.regularizer_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Regularizer>(GetArenaForAllocation());
    _impl_.regularizer_ = p;
  }
  return _impl_.regularizer_;
}
inline ::object_detection::protos::Regularizer* Hyperparams::mutable_regularizer() {
  ::object_detection::protos::Regularizer* _msg = _internal_mutable_regularizer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.regularizer)
  return _msg;
}
inline void Hyperparams::set_allocated_regularizer(::object_detection::protos::Regularizer* regularizer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.regularizer_;
  }
  if (regularizer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(regularizer);
    if (message_arena != submessage_arena) {
      regularizer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, regularizer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.regularizer_ = regularizer;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Hyperparams.regularizer)
}

// optional .object_detection.protos.Initializer initializer = 3;
inline bool Hyperparams::_internal_has_initializer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.initializer_ != nullptr);
  return value;
}
inline bool Hyperparams::has_initializer() const {
  return _internal_has_initializer();
}
inline void Hyperparams::clear_initializer() {
  if (_impl_.initializer_ != nullptr) _impl_.initializer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::object_detection::protos::Initializer& Hyperparams::_internal_initializer() const {
  const ::object_detection::protos::Initializer* p = _impl_.initializer_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Initializer&>(
      ::object_detection::protos::_Initializer_default_instance_);
}
inline const ::object_detection::protos::Initializer& Hyperparams::initializer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.initializer)
  return _internal_initializer();
}
inline void Hyperparams::unsafe_arena_set_allocated_initializer(
    ::object_detection::protos::Initializer* initializer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.initializer_);
  }
  _impl_.initializer_ = initializer;
  if (initializer) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Hyperparams.initializer)
}
inline ::object_detection::protos::Initializer* Hyperparams::release_initializer() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::Initializer* temp = _impl_.initializer_;
  _impl_.initializer_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::object_detection::protos::Initializer* Hyperparams::unsafe_arena_release_initializer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Hyperparams.initializer)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::Initializer* temp = _impl_.initializer_;
  _impl_.initializer_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Initializer* Hyperparams::_internal_mutable_initializer() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.initializer_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Initializer>(GetArenaForAllocation());
    _impl_.initializer_ = p;
  }
  return _impl_.initializer_;
}
inline ::object_detection::protos::Initializer* Hyperparams::mutable_initializer() {
  ::object_detection::protos::Initializer* _msg = _internal_mutable_initializer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.initializer)
  return _msg;
}
inline void Hyperparams::set_allocated_initializer(::object_detection::protos::Initializer* initializer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.initializer_;
  }
  if (initializer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(initializer);
    if (message_arena != submessage_arena) {
      initializer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, initializer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.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::_internal_has_activation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Hyperparams::has_activation() const {
  return _internal_has_activation();
}
inline void Hyperparams::clear_activation() {
  _impl_.activation_ = 1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::object_detection::protos::Hyperparams_Activation Hyperparams::_internal_activation() const {
  return static_cast< ::object_detection::protos::Hyperparams_Activation >(_impl_.activation_);
}
inline ::object_detection::protos::Hyperparams_Activation Hyperparams::activation() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.activation)
  return _internal_activation();
}
inline void Hyperparams::_internal_set_activation(::object_detection::protos::Hyperparams_Activation value) {
  assert(::object_detection::protos::Hyperparams_Activation_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.activation_ = value;
}
inline void Hyperparams::set_activation(::object_detection::protos::Hyperparams_Activation value) {
  _internal_set_activation(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Hyperparams.activation)
}

// .object_detection.protos.BatchNorm batch_norm = 5;
inline bool Hyperparams::_internal_has_batch_norm() const {
  return normalizer_oneof_case() == kBatchNorm;
}
inline bool Hyperparams::has_batch_norm() const {
  return _internal_has_batch_norm();
}
inline void Hyperparams::set_has_batch_norm() {
  _impl_._oneof_case_[0] = kBatchNorm;
}
inline void Hyperparams::clear_batch_norm() {
  if (_internal_has_batch_norm()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_batch_norm()) {
    clear_has_normalizer_oneof();
    ::object_detection::protos::BatchNorm* temp = _impl_.normalizer_oneof_.batch_norm_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.normalizer_oneof_.batch_norm_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::BatchNorm& Hyperparams::_internal_batch_norm() const {
  return _internal_has_batch_norm()
      ? *_impl_.normalizer_oneof_.batch_norm_
      : reinterpret_cast< ::object_detection::protos::BatchNorm&>(::object_detection::protos::_BatchNorm_default_instance_);
}
inline const ::object_detection::protos::BatchNorm& Hyperparams::batch_norm() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.batch_norm)
  return _internal_batch_norm();
}
inline ::object_detection::protos::BatchNorm* Hyperparams::unsafe_arena_release_batch_norm() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.Hyperparams.batch_norm)
  if (_internal_has_batch_norm()) {
    clear_has_normalizer_oneof();
    ::object_detection::protos::BatchNorm* temp = _impl_.normalizer_oneof_.batch_norm_;
    _impl_.normalizer_oneof_.batch_norm_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Hyperparams::unsafe_arena_set_allocated_batch_norm(::object_detection::protos::BatchNorm* batch_norm) {
  clear_normalizer_oneof();
  if (batch_norm) {
    set_has_batch_norm();
    _impl_.normalizer_oneof_.batch_norm_ = batch_norm;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Hyperparams.batch_norm)
}
inline ::object_detection::protos::BatchNorm* Hyperparams::_internal_mutable_batch_norm() {
  if (!_internal_has_batch_norm()) {
    clear_normalizer_oneof();
    set_has_batch_norm();
    _impl_.normalizer_oneof_.batch_norm_ = CreateMaybeMessage< ::object_detection::protos::BatchNorm >(GetArenaForAllocation());
  }
  return _impl_.normalizer_oneof_.batch_norm_;
}
inline ::object_detection::protos::BatchNorm* Hyperparams::mutable_batch_norm() {
  ::object_detection::protos::BatchNorm* _msg = _internal_mutable_batch_norm();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.batch_norm)
  return _msg;
}

// .object_detection.protos.GroupNorm group_norm = 7;
inline bool Hyperparams::_internal_has_group_norm() const {
  return normalizer_oneof_case() == kGroupNorm;
}
inline bool Hyperparams::has_group_norm() const {
  return _internal_has_group_norm();
}
inline void Hyperparams::set_has_group_norm() {
  _impl_._oneof_case_[0] = kGroupNorm;
}
inline void Hyperparams::clear_group_norm() {
  if (_internal_has_group_norm()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_group_norm()) {
    clear_has_normalizer_oneof();
    ::object_detection::protos::GroupNorm* temp = _impl_.normalizer_oneof_.group_norm_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.normalizer_oneof_.group_norm_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::GroupNorm& Hyperparams::_internal_group_norm() const {
  return _internal_has_group_norm()
      ? *_impl_.normalizer_oneof_.group_norm_
      : reinterpret_cast< ::object_detection::protos::GroupNorm&>(::object_detection::protos::_GroupNorm_default_instance_);
}
inline const ::object_detection::protos::GroupNorm& Hyperparams::group_norm() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.group_norm)
  return _internal_group_norm();
}
inline ::object_detection::protos::GroupNorm* Hyperparams::unsafe_arena_release_group_norm() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.Hyperparams.group_norm)
  if (_internal_has_group_norm()) {
    clear_has_normalizer_oneof();
    ::object_detection::protos::GroupNorm* temp = _impl_.normalizer_oneof_.group_norm_;
    _impl_.normalizer_oneof_.group_norm_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Hyperparams::unsafe_arena_set_allocated_group_norm(::object_detection::protos::GroupNorm* group_norm) {
  clear_normalizer_oneof();
  if (group_norm) {
    set_has_group_norm();
    _impl_.normalizer_oneof_.group_norm_ = group_norm;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Hyperparams.group_norm)
}
inline ::object_detection::protos::GroupNorm* Hyperparams::_internal_mutable_group_norm() {
  if (!_internal_has_group_norm()) {
    clear_normalizer_oneof();
    set_has_group_norm();
    _impl_.normalizer_oneof_.group_norm_ = CreateMaybeMessage< ::object_detection::protos::GroupNorm >(GetArenaForAllocation());
  }
  return _impl_.normalizer_oneof_.group_norm_;
}
inline ::object_detection::protos::GroupNorm* Hyperparams::mutable_group_norm() {
  ::object_detection::protos::GroupNorm* _msg = _internal_mutable_group_norm();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Hyperparams.group_norm)
  return _msg;
}

// optional bool regularize_depthwise = 6 [default = false];
inline bool Hyperparams::_internal_has_regularize_depthwise() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Hyperparams::has_regularize_depthwise() const {
  return _internal_has_regularize_depthwise();
}
inline void Hyperparams::clear_regularize_depthwise() {
  _impl_.regularize_depthwise_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool Hyperparams::_internal_regularize_depthwise() const {
  return _impl_.regularize_depthwise_;
}
inline bool Hyperparams::regularize_depthwise() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Hyperparams.regularize_depthwise)
  return _internal_regularize_depthwise();
}
inline void Hyperparams::_internal_set_regularize_depthwise(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.regularize_depthwise_ = value;
}
inline void Hyperparams::set_regularize_depthwise(bool value) {
  _internal_set_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() {
  _impl_._oneof_case_[0] = NORMALIZER_ONEOF_NOT_SET;
}
inline Hyperparams::NormalizerOneofCase Hyperparams::normalizer_oneof_case() const {
  return Hyperparams::NormalizerOneofCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Regularizer

// .object_detection.protos.L1Regularizer l1_regularizer = 1;
inline bool Regularizer::_internal_has_l1_regularizer() const {
  return regularizer_oneof_case() == kL1Regularizer;
}
inline bool Regularizer::has_l1_regularizer() const {
  return _internal_has_l1_regularizer();
}
inline void Regularizer::set_has_l1_regularizer() {
  _impl_._oneof_case_[0] = kL1Regularizer;
}
inline void Regularizer::clear_l1_regularizer() {
  if (_internal_has_l1_regularizer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_l1_regularizer()) {
    clear_has_regularizer_oneof();
    ::object_detection::protos::L1Regularizer* temp = _impl_.regularizer_oneof_.l1_regularizer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.regularizer_oneof_.l1_regularizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::L1Regularizer& Regularizer::_internal_l1_regularizer() const {
  return _internal_has_l1_regularizer()
      ? *_impl_.regularizer_oneof_.l1_regularizer_
      : reinterpret_cast< ::object_detection::protos::L1Regularizer&>(::object_detection::protos::_L1Regularizer_default_instance_);
}
inline const ::object_detection::protos::L1Regularizer& Regularizer::l1_regularizer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Regularizer.l1_regularizer)
  return _internal_l1_regularizer();
}
inline ::object_detection::protos::L1Regularizer* Regularizer::unsafe_arena_release_l1_regularizer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.Regularizer.l1_regularizer)
  if (_internal_has_l1_regularizer()) {
    clear_has_regularizer_oneof();
    ::object_detection::protos::L1Regularizer* temp = _impl_.regularizer_oneof_.l1_regularizer_;
    _impl_.regularizer_oneof_.l1_regularizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Regularizer::unsafe_arena_set_allocated_l1_regularizer(::object_detection::protos::L1Regularizer* l1_regularizer) {
  clear_regularizer_oneof();
  if (l1_regularizer) {
    set_has_l1_regularizer();
    _impl_.regularizer_oneof_.l1_regularizer_ = l1_regularizer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Regularizer.l1_regularizer)
}
inline ::object_detection::protos::L1Regularizer* Regularizer::_internal_mutable_l1_regularizer() {
  if (!_internal_has_l1_regularizer()) {
    clear_regularizer_oneof();
    set_has_l1_regularizer();
    _impl_.regularizer_oneof_.l1_regularizer_ = CreateMaybeMessage< ::object_detection::protos::L1Regularizer >(GetArenaForAllocation());
  }
  return _impl_.regularizer_oneof_.l1_regularizer_;
}
inline ::object_detection::protos::L1Regularizer* Regularizer::mutable_l1_regularizer() {
  ::object_detection::protos::L1Regularizer* _msg = _internal_mutable_l1_regularizer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Regularizer.l1_regularizer)
  return _msg;
}

// .object_detection.protos.L2Regularizer l2_regularizer = 2;
inline bool Regularizer::_internal_has_l2_regularizer() const {
  return regularizer_oneof_case() == kL2Regularizer;
}
inline bool Regularizer::has_l2_regularizer() const {
  return _internal_has_l2_regularizer();
}
inline void Regularizer::set_has_l2_regularizer() {
  _impl_._oneof_case_[0] = kL2Regularizer;
}
inline void Regularizer::clear_l2_regularizer() {
  if (_internal_has_l2_regularizer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_l2_regularizer()) {
    clear_has_regularizer_oneof();
    ::object_detection::protos::L2Regularizer* temp = _impl_.regularizer_oneof_.l2_regularizer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.regularizer_oneof_.l2_regularizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::L2Regularizer& Regularizer::_internal_l2_regularizer() const {
  return _internal_has_l2_regularizer()
      ? *_impl_.regularizer_oneof_.l2_regularizer_
      : reinterpret_cast< ::object_detection::protos::L2Regularizer&>(::object_detection::protos::_L2Regularizer_default_instance_);
}
inline const ::object_detection::protos::L2Regularizer& Regularizer::l2_regularizer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Regularizer.l2_regularizer)
  return _internal_l2_regularizer();
}
inline ::object_detection::protos::L2Regularizer* Regularizer::unsafe_arena_release_l2_regularizer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.Regularizer.l2_regularizer)
  if (_internal_has_l2_regularizer()) {
    clear_has_regularizer_oneof();
    ::object_detection::protos::L2Regularizer* temp = _impl_.regularizer_oneof_.l2_regularizer_;
    _impl_.regularizer_oneof_.l2_regularizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Regularizer::unsafe_arena_set_allocated_l2_regularizer(::object_detection::protos::L2Regularizer* l2_regularizer) {
  clear_regularizer_oneof();
  if (l2_regularizer) {
    set_has_l2_regularizer();
    _impl_.regularizer_oneof_.l2_regularizer_ = l2_regularizer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Regularizer.l2_regularizer)
}
inline ::object_detection::protos::L2Regularizer* Regularizer::_internal_mutable_l2_regularizer() {
  if (!_internal_has_l2_regularizer()) {
    clear_regularizer_oneof();
    set_has_l2_regularizer();
    _impl_.regularizer_oneof_.l2_regularizer_ = CreateMaybeMessage< ::object_detection::protos::L2Regularizer >(GetArenaForAllocation());
  }
  return _impl_.regularizer_oneof_.l2_regularizer_;
}
inline ::object_detection::protos::L2Regularizer* Regularizer::mutable_l2_regularizer() {
  ::object_detection::protos::L2Regularizer* _msg = _internal_mutable_l2_regularizer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Regularizer.l2_regularizer)
  return _msg;
}

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

// L1Regularizer

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

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

// L2Regularizer

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

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

// Initializer

// .object_detection.protos.TruncatedNormalInitializer truncated_normal_initializer = 1;
inline bool Initializer::_internal_has_truncated_normal_initializer() const {
  return initializer_oneof_case() == kTruncatedNormalInitializer;
}
inline bool Initializer::has_truncated_normal_initializer() const {
  return _internal_has_truncated_normal_initializer();
}
inline void Initializer::set_has_truncated_normal_initializer() {
  _impl_._oneof_case_[0] = kTruncatedNormalInitializer;
}
inline void Initializer::clear_truncated_normal_initializer() {
  if (_internal_has_truncated_normal_initializer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_truncated_normal_initializer()) {
    clear_has_initializer_oneof();
    ::object_detection::protos::TruncatedNormalInitializer* temp = _impl_.initializer_oneof_.truncated_normal_initializer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.initializer_oneof_.truncated_normal_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::TruncatedNormalInitializer& Initializer::_internal_truncated_normal_initializer() const {
  return _internal_has_truncated_normal_initializer()
      ? *_impl_.initializer_oneof_.truncated_normal_initializer_
      : reinterpret_cast< ::object_detection::protos::TruncatedNormalInitializer&>(::object_detection::protos::_TruncatedNormalInitializer_default_instance_);
}
inline const ::object_detection::protos::TruncatedNormalInitializer& Initializer::truncated_normal_initializer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Initializer.truncated_normal_initializer)
  return _internal_truncated_normal_initializer();
}
inline ::object_detection::protos::TruncatedNormalInitializer* Initializer::unsafe_arena_release_truncated_normal_initializer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.Initializer.truncated_normal_initializer)
  if (_internal_has_truncated_normal_initializer()) {
    clear_has_initializer_oneof();
    ::object_detection::protos::TruncatedNormalInitializer* temp = _impl_.initializer_oneof_.truncated_normal_initializer_;
    _impl_.initializer_oneof_.truncated_normal_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Initializer::unsafe_arena_set_allocated_truncated_normal_initializer(::object_detection::protos::TruncatedNormalInitializer* truncated_normal_initializer) {
  clear_initializer_oneof();
  if (truncated_normal_initializer) {
    set_has_truncated_normal_initializer();
    _impl_.initializer_oneof_.truncated_normal_initializer_ = truncated_normal_initializer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Initializer.truncated_normal_initializer)
}
inline ::object_detection::protos::TruncatedNormalInitializer* Initializer::_internal_mutable_truncated_normal_initializer() {
  if (!_internal_has_truncated_normal_initializer()) {
    clear_initializer_oneof();
    set_has_truncated_normal_initializer();
    _impl_.initializer_oneof_.truncated_normal_initializer_ = CreateMaybeMessage< ::object_detection::protos::TruncatedNormalInitializer >(GetArenaForAllocation());
  }
  return _impl_.initializer_oneof_.truncated_normal_initializer_;
}
inline ::object_detection::protos::TruncatedNormalInitializer* Initializer::mutable_truncated_normal_initializer() {
  ::object_detection::protos::TruncatedNormalInitializer* _msg = _internal_mutable_truncated_normal_initializer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Initializer.truncated_normal_initializer)
  return _msg;
}

// .object_detection.protos.VarianceScalingInitializer variance_scaling_initializer = 2;
inline bool Initializer::_internal_has_variance_scaling_initializer() const {
  return initializer_oneof_case() == kVarianceScalingInitializer;
}
inline bool Initializer::has_variance_scaling_initializer() const {
  return _internal_has_variance_scaling_initializer();
}
inline void Initializer::set_has_variance_scaling_initializer() {
  _impl_._oneof_case_[0] = kVarianceScalingInitializer;
}
inline void Initializer::clear_variance_scaling_initializer() {
  if (_internal_has_variance_scaling_initializer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_variance_scaling_initializer()) {
    clear_has_initializer_oneof();
    ::object_detection::protos::VarianceScalingInitializer* temp = _impl_.initializer_oneof_.variance_scaling_initializer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.initializer_oneof_.variance_scaling_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::VarianceScalingInitializer& Initializer::_internal_variance_scaling_initializer() const {
  return _internal_has_variance_scaling_initializer()
      ? *_impl_.initializer_oneof_.variance_scaling_initializer_
      : reinterpret_cast< ::object_detection::protos::VarianceScalingInitializer&>(::object_detection::protos::_VarianceScalingInitializer_default_instance_);
}
inline const ::object_detection::protos::VarianceScalingInitializer& Initializer::variance_scaling_initializer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Initializer.variance_scaling_initializer)
  return _internal_variance_scaling_initializer();
}
inline ::object_detection::protos::VarianceScalingInitializer* Initializer::unsafe_arena_release_variance_scaling_initializer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.Initializer.variance_scaling_initializer)
  if (_internal_has_variance_scaling_initializer()) {
    clear_has_initializer_oneof();
    ::object_detection::protos::VarianceScalingInitializer* temp = _impl_.initializer_oneof_.variance_scaling_initializer_;
    _impl_.initializer_oneof_.variance_scaling_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Initializer::unsafe_arena_set_allocated_variance_scaling_initializer(::object_detection::protos::VarianceScalingInitializer* variance_scaling_initializer) {
  clear_initializer_oneof();
  if (variance_scaling_initializer) {
    set_has_variance_scaling_initializer();
    _impl_.initializer_oneof_.variance_scaling_initializer_ = variance_scaling_initializer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Initializer.variance_scaling_initializer)
}
inline ::object_detection::protos::VarianceScalingInitializer* Initializer::_internal_mutable_variance_scaling_initializer() {
  if (!_internal_has_variance_scaling_initializer()) {
    clear_initializer_oneof();
    set_has_variance_scaling_initializer();
    _impl_.initializer_oneof_.variance_scaling_initializer_ = CreateMaybeMessage< ::object_detection::protos::VarianceScalingInitializer >(GetArenaForAllocation());
  }
  return _impl_.initializer_oneof_.variance_scaling_initializer_;
}
inline ::object_detection::protos::VarianceScalingInitializer* Initializer::mutable_variance_scaling_initializer() {
  ::object_detection::protos::VarianceScalingInitializer* _msg = _internal_mutable_variance_scaling_initializer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Initializer.variance_scaling_initializer)
  return _msg;
}

// .object_detection.protos.RandomNormalInitializer random_normal_initializer = 3;
inline bool Initializer::_internal_has_random_normal_initializer() const {
  return initializer_oneof_case() == kRandomNormalInitializer;
}
inline bool Initializer::has_random_normal_initializer() const {
  return _internal_has_random_normal_initializer();
}
inline void Initializer::set_has_random_normal_initializer() {
  _impl_._oneof_case_[0] = kRandomNormalInitializer;
}
inline void Initializer::clear_random_normal_initializer() {
  if (_internal_has_random_normal_initializer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_random_normal_initializer()) {
    clear_has_initializer_oneof();
    ::object_detection::protos::RandomNormalInitializer* temp = _impl_.initializer_oneof_.random_normal_initializer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.initializer_oneof_.random_normal_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::RandomNormalInitializer& Initializer::_internal_random_normal_initializer() const {
  return _internal_has_random_normal_initializer()
      ? *_impl_.initializer_oneof_.random_normal_initializer_
      : reinterpret_cast< ::object_detection::protos::RandomNormalInitializer&>(::object_detection::protos::_RandomNormalInitializer_default_instance_);
}
inline const ::object_detection::protos::RandomNormalInitializer& Initializer::random_normal_initializer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Initializer.random_normal_initializer)
  return _internal_random_normal_initializer();
}
inline ::object_detection::protos::RandomNormalInitializer* Initializer::unsafe_arena_release_random_normal_initializer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.Initializer.random_normal_initializer)
  if (_internal_has_random_normal_initializer()) {
    clear_has_initializer_oneof();
    ::object_detection::protos::RandomNormalInitializer* temp = _impl_.initializer_oneof_.random_normal_initializer_;
    _impl_.initializer_oneof_.random_normal_initializer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Initializer::unsafe_arena_set_allocated_random_normal_initializer(::object_detection::protos::RandomNormalInitializer* random_normal_initializer) {
  clear_initializer_oneof();
  if (random_normal_initializer) {
    set_has_random_normal_initializer();
    _impl_.initializer_oneof_.random_normal_initializer_ = random_normal_initializer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Initializer.random_normal_initializer)
}
inline ::object_detection::protos::RandomNormalInitializer* Initializer::_internal_mutable_random_normal_initializer() {
  if (!_internal_has_random_normal_initializer()) {
    clear_initializer_oneof();
    set_has_random_normal_initializer();
    _impl_.initializer_oneof_.random_normal_initializer_ = CreateMaybeMessage< ::object_detection::protos::RandomNormalInitializer >(GetArenaForAllocation());
  }
  return _impl_.initializer_oneof_.random_normal_initializer_;
}
inline ::object_detection::protos::RandomNormalInitializer* Initializer::mutable_random_normal_initializer() {
  ::object_detection::protos::RandomNormalInitializer* _msg = _internal_mutable_random_normal_initializer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Initializer.random_normal_initializer)
  return _msg;
}

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

// TruncatedNormalInitializer

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

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

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

// VarianceScalingInitializer

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

// optional bool uniform = 2 [default = false];
inline bool VarianceScalingInitializer::_internal_has_uniform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool VarianceScalingInitializer::has_uniform() const {
  return _internal_has_uniform();
}
inline void VarianceScalingInitializer::clear_uniform() {
  _impl_.uniform_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool VarianceScalingInitializer::_internal_uniform() const {
  return _impl_.uniform_;
}
inline bool VarianceScalingInitializer::uniform() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.VarianceScalingInitializer.uniform)
  return _internal_uniform();
}
inline void VarianceScalingInitializer::_internal_set_uniform(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.uniform_ = value;
}
inline void VarianceScalingInitializer::set_uniform(bool value) {
  _internal_set_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::_internal_has_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool VarianceScalingInitializer::has_mode() const {
  return _internal_has_mode();
}
inline void VarianceScalingInitializer::clear_mode() {
  _impl_.mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::object_detection::protos::VarianceScalingInitializer_Mode VarianceScalingInitializer::_internal_mode() const {
  return static_cast< ::object_detection::protos::VarianceScalingInitializer_Mode >(_impl_.mode_);
}
inline ::object_detection::protos::VarianceScalingInitializer_Mode VarianceScalingInitializer::mode() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.VarianceScalingInitializer.mode)
  return _internal_mode();
}
inline void VarianceScalingInitializer::_internal_set_mode(::object_detection::protos::VarianceScalingInitializer_Mode value) {
  assert(::object_detection::protos::VarianceScalingInitializer_Mode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mode_ = value;
}
inline void VarianceScalingInitializer::set_mode(::object_detection::protos::VarianceScalingInitializer_Mode value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.VarianceScalingInitializer.mode)
}

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

// RandomNormalInitializer

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

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

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

// BatchNorm

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

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

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

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

// optional bool train = 5 [default = true];
inline bool BatchNorm::_internal_has_train() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool BatchNorm::has_train() const {
  return _internal_has_train();
}
inline void BatchNorm::clear_train() {
  _impl_.train_ = true;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool BatchNorm::_internal_train() const {
  return _impl_.train_;
}
inline bool BatchNorm::train() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BatchNorm.train)
  return _internal_train();
}
inline void BatchNorm::_internal_set_train(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.train_ = value;
}
inline void BatchNorm::set_train(bool value) {
  _internal_set_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
