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

#ifndef GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fssd_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2fssd_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_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/unknown_field_set.h>
#include "object_detection/protos/anchor_generator.pb.h"
#include "object_detection/protos/box_coder.pb.h"
#include "object_detection/protos/box_predictor.pb.h"
#include "object_detection/protos/hyperparams.pb.h"
#include "object_detection/protos/image_resizer.pb.h"
#include "object_detection/protos/losses.pb.h"
#include "object_detection/protos/matcher.pb.h"
#include "object_detection/protos/post_processing.pb.h"
#include "object_detection/protos/region_similarity_calculator.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_object_5fdetection_2fprotos_2fssd_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_2fssd_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_object_5fdetection_2fprotos_2fssd_2eproto;
namespace object_detection {
namespace protos {
class FeaturePyramidNetworks;
struct FeaturePyramidNetworksDefaultTypeInternal;
extern FeaturePyramidNetworksDefaultTypeInternal _FeaturePyramidNetworks_default_instance_;
class Ssd;
struct SsdDefaultTypeInternal;
extern SsdDefaultTypeInternal _Ssd_default_instance_;
class SsdFeatureExtractor;
struct SsdFeatureExtractorDefaultTypeInternal;
extern SsdFeatureExtractorDefaultTypeInternal _SsdFeatureExtractor_default_instance_;
class Ssd_MaskHead;
struct Ssd_MaskHeadDefaultTypeInternal;
extern Ssd_MaskHeadDefaultTypeInternal _Ssd_MaskHead_default_instance_;
}  // namespace protos
}  // namespace object_detection
PROTOBUF_NAMESPACE_OPEN
template<> ::object_detection::protos::FeaturePyramidNetworks* Arena::CreateMaybeMessage<::object_detection::protos::FeaturePyramidNetworks>(Arena*);
template<> ::object_detection::protos::Ssd* Arena::CreateMaybeMessage<::object_detection::protos::Ssd>(Arena*);
template<> ::object_detection::protos::SsdFeatureExtractor* Arena::CreateMaybeMessage<::object_detection::protos::SsdFeatureExtractor>(Arena*);
template<> ::object_detection::protos::Ssd_MaskHead* Arena::CreateMaybeMessage<::object_detection::protos::Ssd_MaskHead>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace object_detection {
namespace protos {

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

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

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

  inline Ssd_MaskHead& operator=(const Ssd_MaskHead& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ssd_MaskHead& operator=(Ssd_MaskHead&& 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 Ssd_MaskHead& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ssd_MaskHead* internal_default_instance() {
    return reinterpret_cast<const Ssd_MaskHead*>(
               &_Ssd_MaskHead_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Ssd_MaskHead& a, Ssd_MaskHead& b) {
    a.Swap(&b);
  }
  inline void Swap(Ssd_MaskHead* 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(Ssd_MaskHead* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ssd_MaskHead* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ssd_MaskHead>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Ssd_MaskHead& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Ssd_MaskHead& from) {
    Ssd_MaskHead::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(Ssd_MaskHead* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Ssd.MaskHead";
  }
  protected:
  explicit Ssd_MaskHead(::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 {
    kConvHyperparamsFieldNumber = 9,
    kConvolveThenUpsampleMasksFieldNumber = 6,
    kMaskHeightFieldNumber = 1,
    kMaskWidthFieldNumber = 2,
    kMasksAreClassAgnosticFieldNumber = 3,
    kMaskPredictionConvDepthFieldNumber = 4,
    kMaskPredictionNumConvLayersFieldNumber = 5,
    kMaskLossWeightFieldNumber = 7,
    kMaskLossSampleSizeFieldNumber = 8,
    kInitialCropSizeFieldNumber = 10,
  };
  // optional .object_detection.protos.Hyperparams conv_hyperparams = 9;
  bool has_conv_hyperparams() const;
  private:
  bool _internal_has_conv_hyperparams() const;
  public:
  void clear_conv_hyperparams();
  const ::object_detection::protos::Hyperparams& conv_hyperparams() const;
  PROTOBUF_NODISCARD ::object_detection::protos::Hyperparams* release_conv_hyperparams();
  ::object_detection::protos::Hyperparams* mutable_conv_hyperparams();
  void set_allocated_conv_hyperparams(::object_detection::protos::Hyperparams* conv_hyperparams);
  private:
  const ::object_detection::protos::Hyperparams& _internal_conv_hyperparams() const;
  ::object_detection::protos::Hyperparams* _internal_mutable_conv_hyperparams();
  public:
  void unsafe_arena_set_allocated_conv_hyperparams(
      ::object_detection::protos::Hyperparams* conv_hyperparams);
  ::object_detection::protos::Hyperparams* unsafe_arena_release_conv_hyperparams();

  // optional bool convolve_then_upsample_masks = 6 [default = false];
  bool has_convolve_then_upsample_masks() const;
  private:
  bool _internal_has_convolve_then_upsample_masks() const;
  public:
  void clear_convolve_then_upsample_masks();
  bool convolve_then_upsample_masks() const;
  void set_convolve_then_upsample_masks(bool value);
  private:
  bool _internal_convolve_then_upsample_masks() const;
  void _internal_set_convolve_then_upsample_masks(bool value);
  public:

  // optional int32 mask_height = 1 [default = 15];
  bool has_mask_height() const;
  private:
  bool _internal_has_mask_height() const;
  public:
  void clear_mask_height();
  int32_t mask_height() const;
  void set_mask_height(int32_t value);
  private:
  int32_t _internal_mask_height() const;
  void _internal_set_mask_height(int32_t value);
  public:

  // optional int32 mask_width = 2 [default = 15];
  bool has_mask_width() const;
  private:
  bool _internal_has_mask_width() const;
  public:
  void clear_mask_width();
  int32_t mask_width() const;
  void set_mask_width(int32_t value);
  private:
  int32_t _internal_mask_width() const;
  void _internal_set_mask_width(int32_t value);
  public:

  // optional bool masks_are_class_agnostic = 3 [default = true];
  bool has_masks_are_class_agnostic() const;
  private:
  bool _internal_has_masks_are_class_agnostic() const;
  public:
  void clear_masks_are_class_agnostic();
  bool masks_are_class_agnostic() const;
  void set_masks_are_class_agnostic(bool value);
  private:
  bool _internal_masks_are_class_agnostic() const;
  void _internal_set_masks_are_class_agnostic(bool value);
  public:

  // optional int32 mask_prediction_conv_depth = 4 [default = 256];
  bool has_mask_prediction_conv_depth() const;
  private:
  bool _internal_has_mask_prediction_conv_depth() const;
  public:
  void clear_mask_prediction_conv_depth();
  int32_t mask_prediction_conv_depth() const;
  void set_mask_prediction_conv_depth(int32_t value);
  private:
  int32_t _internal_mask_prediction_conv_depth() const;
  void _internal_set_mask_prediction_conv_depth(int32_t value);
  public:

  // optional int32 mask_prediction_num_conv_layers = 5 [default = 2];
  bool has_mask_prediction_num_conv_layers() const;
  private:
  bool _internal_has_mask_prediction_num_conv_layers() const;
  public:
  void clear_mask_prediction_num_conv_layers();
  int32_t mask_prediction_num_conv_layers() const;
  void set_mask_prediction_num_conv_layers(int32_t value);
  private:
  int32_t _internal_mask_prediction_num_conv_layers() const;
  void _internal_set_mask_prediction_num_conv_layers(int32_t value);
  public:

  // optional float mask_loss_weight = 7 [default = 5];
  bool has_mask_loss_weight() const;
  private:
  bool _internal_has_mask_loss_weight() const;
  public:
  void clear_mask_loss_weight();
  float mask_loss_weight() const;
  void set_mask_loss_weight(float value);
  private:
  float _internal_mask_loss_weight() const;
  void _internal_set_mask_loss_weight(float value);
  public:

  // optional int32 mask_loss_sample_size = 8 [default = 16];
  bool has_mask_loss_sample_size() const;
  private:
  bool _internal_has_mask_loss_sample_size() const;
  public:
  void clear_mask_loss_sample_size();
  int32_t mask_loss_sample_size() const;
  void set_mask_loss_sample_size(int32_t value);
  private:
  int32_t _internal_mask_loss_sample_size() const;
  void _internal_set_mask_loss_sample_size(int32_t value);
  public:

  // optional int32 initial_crop_size = 10 [default = 15];
  bool has_initial_crop_size() const;
  private:
  bool _internal_has_initial_crop_size() const;
  public:
  void clear_initial_crop_size();
  int32_t initial_crop_size() const;
  void set_initial_crop_size(int32_t value);
  private:
  int32_t _internal_initial_crop_size() const;
  void _internal_set_initial_crop_size(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.Ssd.MaskHead)
 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_;
    ::object_detection::protos::Hyperparams* conv_hyperparams_;
    bool convolve_then_upsample_masks_;
    int32_t mask_height_;
    int32_t mask_width_;
    bool masks_are_class_agnostic_;
    int32_t mask_prediction_conv_depth_;
    int32_t mask_prediction_num_conv_layers_;
    float mask_loss_weight_;
    int32_t mask_loss_sample_size_;
    int32_t initial_crop_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fssd_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Ssd& operator=(const Ssd& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ssd& operator=(Ssd&& 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 Ssd& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ssd* internal_default_instance() {
    return reinterpret_cast<const Ssd*>(
               &_Ssd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Ssd& a, Ssd& b) {
    a.Swap(&b);
  }
  inline void Swap(Ssd* 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(Ssd* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ssd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ssd>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Ssd& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Ssd& from) {
    Ssd::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(Ssd* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Ssd";
  }
  protected:
  explicit Ssd(::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 Ssd_MaskHead MaskHead;

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

  enum : int {
    kImageResizerFieldNumber = 2,
    kFeatureExtractorFieldNumber = 3,
    kBoxCoderFieldNumber = 4,
    kMatcherFieldNumber = 5,
    kSimilarityCalculatorFieldNumber = 6,
    kBoxPredictorFieldNumber = 7,
    kAnchorGeneratorFieldNumber = 8,
    kPostProcessingFieldNumber = 9,
    kLossFieldNumber = 11,
    kMaskHeadConfigFieldNumber = 25,
    kNumClassesFieldNumber = 1,
    kEncodeBackgroundAsZerosFieldNumber = 12,
    kNormalizeLocLossByCodesizeFieldNumber = 14,
    kFreezeBatchnormFieldNumber = 16,
    kInplaceBatchnormUpdateFieldNumber = 15,
    kExplicitBackgroundClassFieldNumber = 24,
    kUseConfidencesAsTargetsFieldNumber = 22,
    kImplicitExampleWeightFieldNumber = 23,
    kNegativeClassWeightFieldNumber = 13,
    kNormalizeLossByNumMatchesFieldNumber = 10,
    kAddBackgroundClassFieldNumber = 21,
  };
  // optional .object_detection.protos.ImageResizer image_resizer = 2;
  bool has_image_resizer() const;
  private:
  bool _internal_has_image_resizer() const;
  public:
  void clear_image_resizer();
  const ::object_detection::protos::ImageResizer& image_resizer() const;
  PROTOBUF_NODISCARD ::object_detection::protos::ImageResizer* release_image_resizer();
  ::object_detection::protos::ImageResizer* mutable_image_resizer();
  void set_allocated_image_resizer(::object_detection::protos::ImageResizer* image_resizer);
  private:
  const ::object_detection::protos::ImageResizer& _internal_image_resizer() const;
  ::object_detection::protos::ImageResizer* _internal_mutable_image_resizer();
  public:
  void unsafe_arena_set_allocated_image_resizer(
      ::object_detection::protos::ImageResizer* image_resizer);
  ::object_detection::protos::ImageResizer* unsafe_arena_release_image_resizer();

  // optional .object_detection.protos.SsdFeatureExtractor feature_extractor = 3;
  bool has_feature_extractor() const;
  private:
  bool _internal_has_feature_extractor() const;
  public:
  void clear_feature_extractor();
  const ::object_detection::protos::SsdFeatureExtractor& feature_extractor() const;
  PROTOBUF_NODISCARD ::object_detection::protos::SsdFeatureExtractor* release_feature_extractor();
  ::object_detection::protos::SsdFeatureExtractor* mutable_feature_extractor();
  void set_allocated_feature_extractor(::object_detection::protos::SsdFeatureExtractor* feature_extractor);
  private:
  const ::object_detection::protos::SsdFeatureExtractor& _internal_feature_extractor() const;
  ::object_detection::protos::SsdFeatureExtractor* _internal_mutable_feature_extractor();
  public:
  void unsafe_arena_set_allocated_feature_extractor(
      ::object_detection::protos::SsdFeatureExtractor* feature_extractor);
  ::object_detection::protos::SsdFeatureExtractor* unsafe_arena_release_feature_extractor();

  // optional .object_detection.protos.BoxCoder box_coder = 4;
  bool has_box_coder() const;
  private:
  bool _internal_has_box_coder() const;
  public:
  void clear_box_coder();
  const ::object_detection::protos::BoxCoder& box_coder() const;
  PROTOBUF_NODISCARD ::object_detection::protos::BoxCoder* release_box_coder();
  ::object_detection::protos::BoxCoder* mutable_box_coder();
  void set_allocated_box_coder(::object_detection::protos::BoxCoder* box_coder);
  private:
  const ::object_detection::protos::BoxCoder& _internal_box_coder() const;
  ::object_detection::protos::BoxCoder* _internal_mutable_box_coder();
  public:
  void unsafe_arena_set_allocated_box_coder(
      ::object_detection::protos::BoxCoder* box_coder);
  ::object_detection::protos::BoxCoder* unsafe_arena_release_box_coder();

  // optional .object_detection.protos.Matcher matcher = 5;
  bool has_matcher() const;
  private:
  bool _internal_has_matcher() const;
  public:
  void clear_matcher();
  const ::object_detection::protos::Matcher& matcher() const;
  PROTOBUF_NODISCARD ::object_detection::protos::Matcher* release_matcher();
  ::object_detection::protos::Matcher* mutable_matcher();
  void set_allocated_matcher(::object_detection::protos::Matcher* matcher);
  private:
  const ::object_detection::protos::Matcher& _internal_matcher() const;
  ::object_detection::protos::Matcher* _internal_mutable_matcher();
  public:
  void unsafe_arena_set_allocated_matcher(
      ::object_detection::protos::Matcher* matcher);
  ::object_detection::protos::Matcher* unsafe_arena_release_matcher();

  // optional .object_detection.protos.RegionSimilarityCalculator similarity_calculator = 6;
  bool has_similarity_calculator() const;
  private:
  bool _internal_has_similarity_calculator() const;
  public:
  void clear_similarity_calculator();
  const ::object_detection::protos::RegionSimilarityCalculator& similarity_calculator() const;
  PROTOBUF_NODISCARD ::object_detection::protos::RegionSimilarityCalculator* release_similarity_calculator();
  ::object_detection::protos::RegionSimilarityCalculator* mutable_similarity_calculator();
  void set_allocated_similarity_calculator(::object_detection::protos::RegionSimilarityCalculator* similarity_calculator);
  private:
  const ::object_detection::protos::RegionSimilarityCalculator& _internal_similarity_calculator() const;
  ::object_detection::protos::RegionSimilarityCalculator* _internal_mutable_similarity_calculator();
  public:
  void unsafe_arena_set_allocated_similarity_calculator(
      ::object_detection::protos::RegionSimilarityCalculator* similarity_calculator);
  ::object_detection::protos::RegionSimilarityCalculator* unsafe_arena_release_similarity_calculator();

  // optional .object_detection.protos.BoxPredictor box_predictor = 7;
  bool has_box_predictor() const;
  private:
  bool _internal_has_box_predictor() const;
  public:
  void clear_box_predictor();
  const ::object_detection::protos::BoxPredictor& box_predictor() const;
  PROTOBUF_NODISCARD ::object_detection::protos::BoxPredictor* release_box_predictor();
  ::object_detection::protos::BoxPredictor* mutable_box_predictor();
  void set_allocated_box_predictor(::object_detection::protos::BoxPredictor* box_predictor);
  private:
  const ::object_detection::protos::BoxPredictor& _internal_box_predictor() const;
  ::object_detection::protos::BoxPredictor* _internal_mutable_box_predictor();
  public:
  void unsafe_arena_set_allocated_box_predictor(
      ::object_detection::protos::BoxPredictor* box_predictor);
  ::object_detection::protos::BoxPredictor* unsafe_arena_release_box_predictor();

  // optional .object_detection.protos.AnchorGenerator anchor_generator = 8;
  bool has_anchor_generator() const;
  private:
  bool _internal_has_anchor_generator() const;
  public:
  void clear_anchor_generator();
  const ::object_detection::protos::AnchorGenerator& anchor_generator() const;
  PROTOBUF_NODISCARD ::object_detection::protos::AnchorGenerator* release_anchor_generator();
  ::object_detection::protos::AnchorGenerator* mutable_anchor_generator();
  void set_allocated_anchor_generator(::object_detection::protos::AnchorGenerator* anchor_generator);
  private:
  const ::object_detection::protos::AnchorGenerator& _internal_anchor_generator() const;
  ::object_detection::protos::AnchorGenerator* _internal_mutable_anchor_generator();
  public:
  void unsafe_arena_set_allocated_anchor_generator(
      ::object_detection::protos::AnchorGenerator* anchor_generator);
  ::object_detection::protos::AnchorGenerator* unsafe_arena_release_anchor_generator();

  // optional .object_detection.protos.PostProcessing post_processing = 9;
  bool has_post_processing() const;
  private:
  bool _internal_has_post_processing() const;
  public:
  void clear_post_processing();
  const ::object_detection::protos::PostProcessing& post_processing() const;
  PROTOBUF_NODISCARD ::object_detection::protos::PostProcessing* release_post_processing();
  ::object_detection::protos::PostProcessing* mutable_post_processing();
  void set_allocated_post_processing(::object_detection::protos::PostProcessing* post_processing);
  private:
  const ::object_detection::protos::PostProcessing& _internal_post_processing() const;
  ::object_detection::protos::PostProcessing* _internal_mutable_post_processing();
  public:
  void unsafe_arena_set_allocated_post_processing(
      ::object_detection::protos::PostProcessing* post_processing);
  ::object_detection::protos::PostProcessing* unsafe_arena_release_post_processing();

  // optional .object_detection.protos.Loss loss = 11;
  bool has_loss() const;
  private:
  bool _internal_has_loss() const;
  public:
  void clear_loss();
  const ::object_detection::protos::Loss& loss() const;
  PROTOBUF_NODISCARD ::object_detection::protos::Loss* release_loss();
  ::object_detection::protos::Loss* mutable_loss();
  void set_allocated_loss(::object_detection::protos::Loss* loss);
  private:
  const ::object_detection::protos::Loss& _internal_loss() const;
  ::object_detection::protos::Loss* _internal_mutable_loss();
  public:
  void unsafe_arena_set_allocated_loss(
      ::object_detection::protos::Loss* loss);
  ::object_detection::protos::Loss* unsafe_arena_release_loss();

  // optional .object_detection.protos.Ssd.MaskHead mask_head_config = 25;
  bool has_mask_head_config() const;
  private:
  bool _internal_has_mask_head_config() const;
  public:
  void clear_mask_head_config();
  const ::object_detection::protos::Ssd_MaskHead& mask_head_config() const;
  PROTOBUF_NODISCARD ::object_detection::protos::Ssd_MaskHead* release_mask_head_config();
  ::object_detection::protos::Ssd_MaskHead* mutable_mask_head_config();
  void set_allocated_mask_head_config(::object_detection::protos::Ssd_MaskHead* mask_head_config);
  private:
  const ::object_detection::protos::Ssd_MaskHead& _internal_mask_head_config() const;
  ::object_detection::protos::Ssd_MaskHead* _internal_mutable_mask_head_config();
  public:
  void unsafe_arena_set_allocated_mask_head_config(
      ::object_detection::protos::Ssd_MaskHead* mask_head_config);
  ::object_detection::protos::Ssd_MaskHead* unsafe_arena_release_mask_head_config();

  // optional int32 num_classes = 1;
  bool has_num_classes() const;
  private:
  bool _internal_has_num_classes() const;
  public:
  void clear_num_classes();
  int32_t num_classes() const;
  void set_num_classes(int32_t value);
  private:
  int32_t _internal_num_classes() const;
  void _internal_set_num_classes(int32_t value);
  public:

  // optional bool encode_background_as_zeros = 12 [default = false];
  bool has_encode_background_as_zeros() const;
  private:
  bool _internal_has_encode_background_as_zeros() const;
  public:
  void clear_encode_background_as_zeros();
  bool encode_background_as_zeros() const;
  void set_encode_background_as_zeros(bool value);
  private:
  bool _internal_encode_background_as_zeros() const;
  void _internal_set_encode_background_as_zeros(bool value);
  public:

  // optional bool normalize_loc_loss_by_codesize = 14 [default = false];
  bool has_normalize_loc_loss_by_codesize() const;
  private:
  bool _internal_has_normalize_loc_loss_by_codesize() const;
  public:
  void clear_normalize_loc_loss_by_codesize();
  bool normalize_loc_loss_by_codesize() const;
  void set_normalize_loc_loss_by_codesize(bool value);
  private:
  bool _internal_normalize_loc_loss_by_codesize() const;
  void _internal_set_normalize_loc_loss_by_codesize(bool value);
  public:

  // optional bool freeze_batchnorm = 16 [default = false];
  bool has_freeze_batchnorm() const;
  private:
  bool _internal_has_freeze_batchnorm() const;
  public:
  void clear_freeze_batchnorm();
  bool freeze_batchnorm() const;
  void set_freeze_batchnorm(bool value);
  private:
  bool _internal_freeze_batchnorm() const;
  void _internal_set_freeze_batchnorm(bool value);
  public:

  // optional bool inplace_batchnorm_update = 15 [default = false];
  bool has_inplace_batchnorm_update() const;
  private:
  bool _internal_has_inplace_batchnorm_update() const;
  public:
  void clear_inplace_batchnorm_update();
  bool inplace_batchnorm_update() const;
  void set_inplace_batchnorm_update(bool value);
  private:
  bool _internal_inplace_batchnorm_update() const;
  void _internal_set_inplace_batchnorm_update(bool value);
  public:

  // optional bool explicit_background_class = 24 [default = false];
  bool has_explicit_background_class() const;
  private:
  bool _internal_has_explicit_background_class() const;
  public:
  void clear_explicit_background_class();
  bool explicit_background_class() const;
  void set_explicit_background_class(bool value);
  private:
  bool _internal_explicit_background_class() const;
  void _internal_set_explicit_background_class(bool value);
  public:

  // optional bool use_confidences_as_targets = 22 [default = false];
  bool has_use_confidences_as_targets() const;
  private:
  bool _internal_has_use_confidences_as_targets() const;
  public:
  void clear_use_confidences_as_targets();
  bool use_confidences_as_targets() const;
  void set_use_confidences_as_targets(bool value);
  private:
  bool _internal_use_confidences_as_targets() const;
  void _internal_set_use_confidences_as_targets(bool value);
  public:

  // optional float implicit_example_weight = 23 [default = 1];
  bool has_implicit_example_weight() const;
  private:
  bool _internal_has_implicit_example_weight() const;
  public:
  void clear_implicit_example_weight();
  float implicit_example_weight() const;
  void set_implicit_example_weight(float value);
  private:
  float _internal_implicit_example_weight() const;
  void _internal_set_implicit_example_weight(float value);
  public:

  // optional float negative_class_weight = 13 [default = 1];
  bool has_negative_class_weight() const;
  private:
  bool _internal_has_negative_class_weight() const;
  public:
  void clear_negative_class_weight();
  float negative_class_weight() const;
  void set_negative_class_weight(float value);
  private:
  float _internal_negative_class_weight() const;
  void _internal_set_negative_class_weight(float value);
  public:

  // optional bool normalize_loss_by_num_matches = 10 [default = true];
  bool has_normalize_loss_by_num_matches() const;
  private:
  bool _internal_has_normalize_loss_by_num_matches() const;
  public:
  void clear_normalize_loss_by_num_matches();
  bool normalize_loss_by_num_matches() const;
  void set_normalize_loss_by_num_matches(bool value);
  private:
  bool _internal_normalize_loss_by_num_matches() const;
  void _internal_set_normalize_loss_by_num_matches(bool value);
  public:

  // optional bool add_background_class = 21 [default = true];
  bool has_add_background_class() const;
  private:
  bool _internal_has_add_background_class() const;
  public:
  void clear_add_background_class();
  bool add_background_class() const;
  void set_add_background_class(bool value);
  private:
  bool _internal_add_background_class() const;
  void _internal_set_add_background_class(bool value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.Ssd)
 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_;
    ::object_detection::protos::ImageResizer* image_resizer_;
    ::object_detection::protos::SsdFeatureExtractor* feature_extractor_;
    ::object_detection::protos::BoxCoder* box_coder_;
    ::object_detection::protos::Matcher* matcher_;
    ::object_detection::protos::RegionSimilarityCalculator* similarity_calculator_;
    ::object_detection::protos::BoxPredictor* box_predictor_;
    ::object_detection::protos::AnchorGenerator* anchor_generator_;
    ::object_detection::protos::PostProcessing* post_processing_;
    ::object_detection::protos::Loss* loss_;
    ::object_detection::protos::Ssd_MaskHead* mask_head_config_;
    int32_t num_classes_;
    bool encode_background_as_zeros_;
    bool normalize_loc_loss_by_codesize_;
    bool freeze_batchnorm_;
    bool inplace_batchnorm_update_;
    bool explicit_background_class_;
    bool use_confidences_as_targets_;
    float implicit_example_weight_;
    float negative_class_weight_;
    bool normalize_loss_by_num_matches_;
    bool add_background_class_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fssd_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline SsdFeatureExtractor& operator=(const SsdFeatureExtractor& from) {
    CopyFrom(from);
    return *this;
  }
  inline SsdFeatureExtractor& operator=(SsdFeatureExtractor&& 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 SsdFeatureExtractor& default_instance() {
    return *internal_default_instance();
  }
  static inline const SsdFeatureExtractor* internal_default_instance() {
    return reinterpret_cast<const SsdFeatureExtractor*>(
               &_SsdFeatureExtractor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(SsdFeatureExtractor& a, SsdFeatureExtractor& b) {
    a.Swap(&b);
  }
  inline void Swap(SsdFeatureExtractor* 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(SsdFeatureExtractor* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SsdFeatureExtractor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SsdFeatureExtractor>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SsdFeatureExtractor& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SsdFeatureExtractor& from) {
    SsdFeatureExtractor::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(SsdFeatureExtractor* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SsdFeatureExtractor";
  }
  protected:
  explicit SsdFeatureExtractor(::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 {
    kTypeFieldNumber = 1,
    kConvHyperparamsFieldNumber = 4,
    kFpnFieldNumber = 10,
    kOverrideBaseFeatureExtractorHyperparamsFieldNumber = 9,
    kUseExplicitPaddingFieldNumber = 7,
    kUseDepthwiseFieldNumber = 8,
    kReplacePreprocessorWithPlaceholderFieldNumber = 11,
    kDepthMultiplierFieldNumber = 2,
    kMinDepthFieldNumber = 3,
    kPadToMultipleFieldNumber = 5,
    kNumLayersFieldNumber = 12,
  };
  // optional string type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // optional .object_detection.protos.Hyperparams conv_hyperparams = 4;
  bool has_conv_hyperparams() const;
  private:
  bool _internal_has_conv_hyperparams() const;
  public:
  void clear_conv_hyperparams();
  const ::object_detection::protos::Hyperparams& conv_hyperparams() const;
  PROTOBUF_NODISCARD ::object_detection::protos::Hyperparams* release_conv_hyperparams();
  ::object_detection::protos::Hyperparams* mutable_conv_hyperparams();
  void set_allocated_conv_hyperparams(::object_detection::protos::Hyperparams* conv_hyperparams);
  private:
  const ::object_detection::protos::Hyperparams& _internal_conv_hyperparams() const;
  ::object_detection::protos::Hyperparams* _internal_mutable_conv_hyperparams();
  public:
  void unsafe_arena_set_allocated_conv_hyperparams(
      ::object_detection::protos::Hyperparams* conv_hyperparams);
  ::object_detection::protos::Hyperparams* unsafe_arena_release_conv_hyperparams();

  // optional .object_detection.protos.FeaturePyramidNetworks fpn = 10;
  bool has_fpn() const;
  private:
  bool _internal_has_fpn() const;
  public:
  void clear_fpn();
  const ::object_detection::protos::FeaturePyramidNetworks& fpn() const;
  PROTOBUF_NODISCARD ::object_detection::protos::FeaturePyramidNetworks* release_fpn();
  ::object_detection::protos::FeaturePyramidNetworks* mutable_fpn();
  void set_allocated_fpn(::object_detection::protos::FeaturePyramidNetworks* fpn);
  private:
  const ::object_detection::protos::FeaturePyramidNetworks& _internal_fpn() const;
  ::object_detection::protos::FeaturePyramidNetworks* _internal_mutable_fpn();
  public:
  void unsafe_arena_set_allocated_fpn(
      ::object_detection::protos::FeaturePyramidNetworks* fpn);
  ::object_detection::protos::FeaturePyramidNetworks* unsafe_arena_release_fpn();

  // optional bool override_base_feature_extractor_hyperparams = 9 [default = false];
  bool has_override_base_feature_extractor_hyperparams() const;
  private:
  bool _internal_has_override_base_feature_extractor_hyperparams() const;
  public:
  void clear_override_base_feature_extractor_hyperparams();
  bool override_base_feature_extractor_hyperparams() const;
  void set_override_base_feature_extractor_hyperparams(bool value);
  private:
  bool _internal_override_base_feature_extractor_hyperparams() const;
  void _internal_set_override_base_feature_extractor_hyperparams(bool value);
  public:

  // optional bool use_explicit_padding = 7 [default = false];
  bool has_use_explicit_padding() const;
  private:
  bool _internal_has_use_explicit_padding() const;
  public:
  void clear_use_explicit_padding();
  bool use_explicit_padding() const;
  void set_use_explicit_padding(bool value);
  private:
  bool _internal_use_explicit_padding() const;
  void _internal_set_use_explicit_padding(bool value);
  public:

  // optional bool use_depthwise = 8 [default = false];
  bool has_use_depthwise() const;
  private:
  bool _internal_has_use_depthwise() const;
  public:
  void clear_use_depthwise();
  bool use_depthwise() const;
  void set_use_depthwise(bool value);
  private:
  bool _internal_use_depthwise() const;
  void _internal_set_use_depthwise(bool value);
  public:

  // optional bool replace_preprocessor_with_placeholder = 11 [default = false];
  bool has_replace_preprocessor_with_placeholder() const;
  private:
  bool _internal_has_replace_preprocessor_with_placeholder() const;
  public:
  void clear_replace_preprocessor_with_placeholder();
  bool replace_preprocessor_with_placeholder() const;
  void set_replace_preprocessor_with_placeholder(bool value);
  private:
  bool _internal_replace_preprocessor_with_placeholder() const;
  void _internal_set_replace_preprocessor_with_placeholder(bool value);
  public:

  // optional float depth_multiplier = 2 [default = 1];
  bool has_depth_multiplier() const;
  private:
  bool _internal_has_depth_multiplier() const;
  public:
  void clear_depth_multiplier();
  float depth_multiplier() const;
  void set_depth_multiplier(float value);
  private:
  float _internal_depth_multiplier() const;
  void _internal_set_depth_multiplier(float value);
  public:

  // optional int32 min_depth = 3 [default = 16];
  bool has_min_depth() const;
  private:
  bool _internal_has_min_depth() const;
  public:
  void clear_min_depth();
  int32_t min_depth() const;
  void set_min_depth(int32_t value);
  private:
  int32_t _internal_min_depth() const;
  void _internal_set_min_depth(int32_t value);
  public:

  // optional int32 pad_to_multiple = 5 [default = 1];
  bool has_pad_to_multiple() const;
  private:
  bool _internal_has_pad_to_multiple() const;
  public:
  void clear_pad_to_multiple();
  int32_t pad_to_multiple() const;
  void set_pad_to_multiple(int32_t value);
  private:
  int32_t _internal_pad_to_multiple() const;
  void _internal_set_pad_to_multiple(int32_t value);
  public:

  // optional int32 num_layers = 12 [default = 6];
  bool has_num_layers() const;
  private:
  bool _internal_has_num_layers() const;
  public:
  void clear_num_layers();
  int32_t num_layers() const;
  void set_num_layers(int32_t value);
  private:
  int32_t _internal_num_layers() const;
  void _internal_set_num_layers(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.SsdFeatureExtractor)
 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_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
    ::object_detection::protos::Hyperparams* conv_hyperparams_;
    ::object_detection::protos::FeaturePyramidNetworks* fpn_;
    bool override_base_feature_extractor_hyperparams_;
    bool use_explicit_padding_;
    bool use_depthwise_;
    bool replace_preprocessor_with_placeholder_;
    float depth_multiplier_;
    int32_t min_depth_;
    int32_t pad_to_multiple_;
    int32_t num_layers_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fssd_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline FeaturePyramidNetworks& operator=(const FeaturePyramidNetworks& from) {
    CopyFrom(from);
    return *this;
  }
  inline FeaturePyramidNetworks& operator=(FeaturePyramidNetworks&& 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 FeaturePyramidNetworks& default_instance() {
    return *internal_default_instance();
  }
  static inline const FeaturePyramidNetworks* internal_default_instance() {
    return reinterpret_cast<const FeaturePyramidNetworks*>(
               &_FeaturePyramidNetworks_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(FeaturePyramidNetworks& a, FeaturePyramidNetworks& b) {
    a.Swap(&b);
  }
  inline void Swap(FeaturePyramidNetworks* 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(FeaturePyramidNetworks* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FeaturePyramidNetworks* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FeaturePyramidNetworks>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FeaturePyramidNetworks& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FeaturePyramidNetworks& from) {
    FeaturePyramidNetworks::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(FeaturePyramidNetworks* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.FeaturePyramidNetworks";
  }
  protected:
  explicit FeaturePyramidNetworks(::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 {
    kAdditionalLayerDepthFieldNumber = 3,
    kMinLevelFieldNumber = 1,
    kMaxLevelFieldNumber = 2,
  };
  // optional int32 additional_layer_depth = 3 [default = 256];
  bool has_additional_layer_depth() const;
  private:
  bool _internal_has_additional_layer_depth() const;
  public:
  void clear_additional_layer_depth();
  int32_t additional_layer_depth() const;
  void set_additional_layer_depth(int32_t value);
  private:
  int32_t _internal_additional_layer_depth() const;
  void _internal_set_additional_layer_depth(int32_t value);
  public:

  // optional int32 min_level = 1 [default = 3];
  bool has_min_level() const;
  private:
  bool _internal_has_min_level() const;
  public:
  void clear_min_level();
  int32_t min_level() const;
  void set_min_level(int32_t value);
  private:
  int32_t _internal_min_level() const;
  void _internal_set_min_level(int32_t value);
  public:

  // optional int32 max_level = 2 [default = 7];
  bool has_max_level() const;
  private:
  bool _internal_has_max_level() const;
  public:
  void clear_max_level();
  int32_t max_level() const;
  void set_max_level(int32_t value);
  private:
  int32_t _internal_max_level() const;
  void _internal_set_max_level(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.FeaturePyramidNetworks)
 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_;
    int32_t additional_layer_depth_;
    int32_t min_level_;
    int32_t max_level_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fssd_2eproto;
};
// ===================================================================


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

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

// optional int32 mask_height = 1 [default = 15];
inline bool Ssd_MaskHead::_internal_has_mask_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_mask_height() const {
  return _internal_has_mask_height();
}
inline void Ssd_MaskHead::clear_mask_height() {
  _impl_.mask_height_ = 15;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t Ssd_MaskHead::_internal_mask_height() const {
  return _impl_.mask_height_;
}
inline int32_t Ssd_MaskHead::mask_height() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_height)
  return _internal_mask_height();
}
inline void Ssd_MaskHead::_internal_set_mask_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.mask_height_ = value;
}
inline void Ssd_MaskHead::set_mask_height(int32_t value) {
  _internal_set_mask_height(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.mask_height)
}

// optional int32 mask_width = 2 [default = 15];
inline bool Ssd_MaskHead::_internal_has_mask_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_mask_width() const {
  return _internal_has_mask_width();
}
inline void Ssd_MaskHead::clear_mask_width() {
  _impl_.mask_width_ = 15;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t Ssd_MaskHead::_internal_mask_width() const {
  return _impl_.mask_width_;
}
inline int32_t Ssd_MaskHead::mask_width() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_width)
  return _internal_mask_width();
}
inline void Ssd_MaskHead::_internal_set_mask_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mask_width_ = value;
}
inline void Ssd_MaskHead::set_mask_width(int32_t value) {
  _internal_set_mask_width(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.mask_width)
}

// optional bool masks_are_class_agnostic = 3 [default = true];
inline bool Ssd_MaskHead::_internal_has_masks_are_class_agnostic() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_masks_are_class_agnostic() const {
  return _internal_has_masks_are_class_agnostic();
}
inline void Ssd_MaskHead::clear_masks_are_class_agnostic() {
  _impl_.masks_are_class_agnostic_ = true;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool Ssd_MaskHead::_internal_masks_are_class_agnostic() const {
  return _impl_.masks_are_class_agnostic_;
}
inline bool Ssd_MaskHead::masks_are_class_agnostic() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.masks_are_class_agnostic)
  return _internal_masks_are_class_agnostic();
}
inline void Ssd_MaskHead::_internal_set_masks_are_class_agnostic(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.masks_are_class_agnostic_ = value;
}
inline void Ssd_MaskHead::set_masks_are_class_agnostic(bool value) {
  _internal_set_masks_are_class_agnostic(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.masks_are_class_agnostic)
}

// optional int32 mask_prediction_conv_depth = 4 [default = 256];
inline bool Ssd_MaskHead::_internal_has_mask_prediction_conv_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_mask_prediction_conv_depth() const {
  return _internal_has_mask_prediction_conv_depth();
}
inline void Ssd_MaskHead::clear_mask_prediction_conv_depth() {
  _impl_.mask_prediction_conv_depth_ = 256;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t Ssd_MaskHead::_internal_mask_prediction_conv_depth() const {
  return _impl_.mask_prediction_conv_depth_;
}
inline int32_t Ssd_MaskHead::mask_prediction_conv_depth() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_prediction_conv_depth)
  return _internal_mask_prediction_conv_depth();
}
inline void Ssd_MaskHead::_internal_set_mask_prediction_conv_depth(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.mask_prediction_conv_depth_ = value;
}
inline void Ssd_MaskHead::set_mask_prediction_conv_depth(int32_t value) {
  _internal_set_mask_prediction_conv_depth(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.mask_prediction_conv_depth)
}

// optional int32 mask_prediction_num_conv_layers = 5 [default = 2];
inline bool Ssd_MaskHead::_internal_has_mask_prediction_num_conv_layers() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_mask_prediction_num_conv_layers() const {
  return _internal_has_mask_prediction_num_conv_layers();
}
inline void Ssd_MaskHead::clear_mask_prediction_num_conv_layers() {
  _impl_.mask_prediction_num_conv_layers_ = 2;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t Ssd_MaskHead::_internal_mask_prediction_num_conv_layers() const {
  return _impl_.mask_prediction_num_conv_layers_;
}
inline int32_t Ssd_MaskHead::mask_prediction_num_conv_layers() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_prediction_num_conv_layers)
  return _internal_mask_prediction_num_conv_layers();
}
inline void Ssd_MaskHead::_internal_set_mask_prediction_num_conv_layers(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.mask_prediction_num_conv_layers_ = value;
}
inline void Ssd_MaskHead::set_mask_prediction_num_conv_layers(int32_t value) {
  _internal_set_mask_prediction_num_conv_layers(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.mask_prediction_num_conv_layers)
}

// optional bool convolve_then_upsample_masks = 6 [default = false];
inline bool Ssd_MaskHead::_internal_has_convolve_then_upsample_masks() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_convolve_then_upsample_masks() const {
  return _internal_has_convolve_then_upsample_masks();
}
inline void Ssd_MaskHead::clear_convolve_then_upsample_masks() {
  _impl_.convolve_then_upsample_masks_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool Ssd_MaskHead::_internal_convolve_then_upsample_masks() const {
  return _impl_.convolve_then_upsample_masks_;
}
inline bool Ssd_MaskHead::convolve_then_upsample_masks() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.convolve_then_upsample_masks)
  return _internal_convolve_then_upsample_masks();
}
inline void Ssd_MaskHead::_internal_set_convolve_then_upsample_masks(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.convolve_then_upsample_masks_ = value;
}
inline void Ssd_MaskHead::set_convolve_then_upsample_masks(bool value) {
  _internal_set_convolve_then_upsample_masks(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.convolve_then_upsample_masks)
}

// optional float mask_loss_weight = 7 [default = 5];
inline bool Ssd_MaskHead::_internal_has_mask_loss_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_mask_loss_weight() const {
  return _internal_has_mask_loss_weight();
}
inline void Ssd_MaskHead::clear_mask_loss_weight() {
  _impl_.mask_loss_weight_ = 5;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float Ssd_MaskHead::_internal_mask_loss_weight() const {
  return _impl_.mask_loss_weight_;
}
inline float Ssd_MaskHead::mask_loss_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_loss_weight)
  return _internal_mask_loss_weight();
}
inline void Ssd_MaskHead::_internal_set_mask_loss_weight(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.mask_loss_weight_ = value;
}
inline void Ssd_MaskHead::set_mask_loss_weight(float value) {
  _internal_set_mask_loss_weight(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.mask_loss_weight)
}

// optional int32 mask_loss_sample_size = 8 [default = 16];
inline bool Ssd_MaskHead::_internal_has_mask_loss_sample_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_mask_loss_sample_size() const {
  return _internal_has_mask_loss_sample_size();
}
inline void Ssd_MaskHead::clear_mask_loss_sample_size() {
  _impl_.mask_loss_sample_size_ = 16;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t Ssd_MaskHead::_internal_mask_loss_sample_size() const {
  return _impl_.mask_loss_sample_size_;
}
inline int32_t Ssd_MaskHead::mask_loss_sample_size() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_loss_sample_size)
  return _internal_mask_loss_sample_size();
}
inline void Ssd_MaskHead::_internal_set_mask_loss_sample_size(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.mask_loss_sample_size_ = value;
}
inline void Ssd_MaskHead::set_mask_loss_sample_size(int32_t value) {
  _internal_set_mask_loss_sample_size(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.mask_loss_sample_size)
}

// optional .object_detection.protos.Hyperparams conv_hyperparams = 9;
inline bool Ssd_MaskHead::_internal_has_conv_hyperparams() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.conv_hyperparams_ != nullptr);
  return value;
}
inline bool Ssd_MaskHead::has_conv_hyperparams() const {
  return _internal_has_conv_hyperparams();
}
inline const ::object_detection::protos::Hyperparams& Ssd_MaskHead::_internal_conv_hyperparams() const {
  const ::object_detection::protos::Hyperparams* p = _impl_.conv_hyperparams_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Hyperparams&>(
      ::object_detection::protos::_Hyperparams_default_instance_);
}
inline const ::object_detection::protos::Hyperparams& Ssd_MaskHead::conv_hyperparams() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
  return _internal_conv_hyperparams();
}
inline void Ssd_MaskHead::unsafe_arena_set_allocated_conv_hyperparams(
    ::object_detection::protos::Hyperparams* conv_hyperparams) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.conv_hyperparams_);
  }
  _impl_.conv_hyperparams_ = conv_hyperparams;
  if (conv_hyperparams) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
}
inline ::object_detection::protos::Hyperparams* Ssd_MaskHead::release_conv_hyperparams() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::Hyperparams* temp = _impl_.conv_hyperparams_;
  _impl_.conv_hyperparams_ = 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::Hyperparams* Ssd_MaskHead::unsafe_arena_release_conv_hyperparams() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::Hyperparams* temp = _impl_.conv_hyperparams_;
  _impl_.conv_hyperparams_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Hyperparams* Ssd_MaskHead::_internal_mutable_conv_hyperparams() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.conv_hyperparams_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Hyperparams>(GetArenaForAllocation());
    _impl_.conv_hyperparams_ = p;
  }
  return _impl_.conv_hyperparams_;
}
inline ::object_detection::protos::Hyperparams* Ssd_MaskHead::mutable_conv_hyperparams() {
  ::object_detection::protos::Hyperparams* _msg = _internal_mutable_conv_hyperparams();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
  return _msg;
}
inline void Ssd_MaskHead::set_allocated_conv_hyperparams(::object_detection::protos::Hyperparams* conv_hyperparams) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.conv_hyperparams_);
  }
  if (conv_hyperparams) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(conv_hyperparams));
    if (message_arena != submessage_arena) {
      conv_hyperparams = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, conv_hyperparams, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.conv_hyperparams_ = conv_hyperparams;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
}

// optional int32 initial_crop_size = 10 [default = 15];
inline bool Ssd_MaskHead::_internal_has_initial_crop_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Ssd_MaskHead::has_initial_crop_size() const {
  return _internal_has_initial_crop_size();
}
inline void Ssd_MaskHead::clear_initial_crop_size() {
  _impl_.initial_crop_size_ = 15;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t Ssd_MaskHead::_internal_initial_crop_size() const {
  return _impl_.initial_crop_size_;
}
inline int32_t Ssd_MaskHead::initial_crop_size() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.initial_crop_size)
  return _internal_initial_crop_size();
}
inline void Ssd_MaskHead::_internal_set_initial_crop_size(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.initial_crop_size_ = value;
}
inline void Ssd_MaskHead::set_initial_crop_size(int32_t value) {
  _internal_set_initial_crop_size(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.MaskHead.initial_crop_size)
}

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

// Ssd

// optional int32 num_classes = 1;
inline bool Ssd::_internal_has_num_classes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Ssd::has_num_classes() const {
  return _internal_has_num_classes();
}
inline void Ssd::clear_num_classes() {
  _impl_.num_classes_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int32_t Ssd::_internal_num_classes() const {
  return _impl_.num_classes_;
}
inline int32_t Ssd::num_classes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.num_classes)
  return _internal_num_classes();
}
inline void Ssd::_internal_set_num_classes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.num_classes_ = value;
}
inline void Ssd::set_num_classes(int32_t value) {
  _internal_set_num_classes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.num_classes)
}

// optional .object_detection.protos.ImageResizer image_resizer = 2;
inline bool Ssd::_internal_has_image_resizer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.image_resizer_ != nullptr);
  return value;
}
inline bool Ssd::has_image_resizer() const {
  return _internal_has_image_resizer();
}
inline const ::object_detection::protos::ImageResizer& Ssd::_internal_image_resizer() const {
  const ::object_detection::protos::ImageResizer* p = _impl_.image_resizer_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::ImageResizer&>(
      ::object_detection::protos::_ImageResizer_default_instance_);
}
inline const ::object_detection::protos::ImageResizer& Ssd::image_resizer() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.image_resizer)
  return _internal_image_resizer();
}
inline void Ssd::unsafe_arena_set_allocated_image_resizer(
    ::object_detection::protos::ImageResizer* image_resizer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_resizer_);
  }
  _impl_.image_resizer_ = image_resizer;
  if (image_resizer) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.image_resizer)
}
inline ::object_detection::protos::ImageResizer* Ssd::release_image_resizer() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::ImageResizer* temp = _impl_.image_resizer_;
  _impl_.image_resizer_ = 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::ImageResizer* Ssd::unsafe_arena_release_image_resizer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.image_resizer)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::ImageResizer* temp = _impl_.image_resizer_;
  _impl_.image_resizer_ = nullptr;
  return temp;
}
inline ::object_detection::protos::ImageResizer* Ssd::_internal_mutable_image_resizer() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.image_resizer_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::ImageResizer>(GetArenaForAllocation());
    _impl_.image_resizer_ = p;
  }
  return _impl_.image_resizer_;
}
inline ::object_detection::protos::ImageResizer* Ssd::mutable_image_resizer() {
  ::object_detection::protos::ImageResizer* _msg = _internal_mutable_image_resizer();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.image_resizer)
  return _msg;
}
inline void Ssd::set_allocated_image_resizer(::object_detection::protos::ImageResizer* image_resizer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_resizer_);
  }
  if (image_resizer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(image_resizer));
    if (message_arena != submessage_arena) {
      image_resizer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, image_resizer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.image_resizer_ = image_resizer;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.image_resizer)
}

// optional .object_detection.protos.SsdFeatureExtractor feature_extractor = 3;
inline bool Ssd::_internal_has_feature_extractor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.feature_extractor_ != nullptr);
  return value;
}
inline bool Ssd::has_feature_extractor() const {
  return _internal_has_feature_extractor();
}
inline void Ssd::clear_feature_extractor() {
  if (_impl_.feature_extractor_ != nullptr) _impl_.feature_extractor_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::object_detection::protos::SsdFeatureExtractor& Ssd::_internal_feature_extractor() const {
  const ::object_detection::protos::SsdFeatureExtractor* p = _impl_.feature_extractor_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::SsdFeatureExtractor&>(
      ::object_detection::protos::_SsdFeatureExtractor_default_instance_);
}
inline const ::object_detection::protos::SsdFeatureExtractor& Ssd::feature_extractor() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.feature_extractor)
  return _internal_feature_extractor();
}
inline void Ssd::unsafe_arena_set_allocated_feature_extractor(
    ::object_detection::protos::SsdFeatureExtractor* feature_extractor) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.feature_extractor_);
  }
  _impl_.feature_extractor_ = feature_extractor;
  if (feature_extractor) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.feature_extractor)
}
inline ::object_detection::protos::SsdFeatureExtractor* Ssd::release_feature_extractor() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::SsdFeatureExtractor* temp = _impl_.feature_extractor_;
  _impl_.feature_extractor_ = 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::SsdFeatureExtractor* Ssd::unsafe_arena_release_feature_extractor() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.feature_extractor)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::SsdFeatureExtractor* temp = _impl_.feature_extractor_;
  _impl_.feature_extractor_ = nullptr;
  return temp;
}
inline ::object_detection::protos::SsdFeatureExtractor* Ssd::_internal_mutable_feature_extractor() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.feature_extractor_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::SsdFeatureExtractor>(GetArenaForAllocation());
    _impl_.feature_extractor_ = p;
  }
  return _impl_.feature_extractor_;
}
inline ::object_detection::protos::SsdFeatureExtractor* Ssd::mutable_feature_extractor() {
  ::object_detection::protos::SsdFeatureExtractor* _msg = _internal_mutable_feature_extractor();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.feature_extractor)
  return _msg;
}
inline void Ssd::set_allocated_feature_extractor(::object_detection::protos::SsdFeatureExtractor* feature_extractor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.feature_extractor_;
  }
  if (feature_extractor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(feature_extractor);
    if (message_arena != submessage_arena) {
      feature_extractor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, feature_extractor, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.feature_extractor_ = feature_extractor;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.feature_extractor)
}

// optional .object_detection.protos.BoxCoder box_coder = 4;
inline bool Ssd::_internal_has_box_coder() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.box_coder_ != nullptr);
  return value;
}
inline bool Ssd::has_box_coder() const {
  return _internal_has_box_coder();
}
inline const ::object_detection::protos::BoxCoder& Ssd::_internal_box_coder() const {
  const ::object_detection::protos::BoxCoder* p = _impl_.box_coder_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::BoxCoder&>(
      ::object_detection::protos::_BoxCoder_default_instance_);
}
inline const ::object_detection::protos::BoxCoder& Ssd::box_coder() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.box_coder)
  return _internal_box_coder();
}
inline void Ssd::unsafe_arena_set_allocated_box_coder(
    ::object_detection::protos::BoxCoder* box_coder) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.box_coder_);
  }
  _impl_.box_coder_ = box_coder;
  if (box_coder) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.box_coder)
}
inline ::object_detection::protos::BoxCoder* Ssd::release_box_coder() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::BoxCoder* temp = _impl_.box_coder_;
  _impl_.box_coder_ = 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::BoxCoder* Ssd::unsafe_arena_release_box_coder() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.box_coder)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::BoxCoder* temp = _impl_.box_coder_;
  _impl_.box_coder_ = nullptr;
  return temp;
}
inline ::object_detection::protos::BoxCoder* Ssd::_internal_mutable_box_coder() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.box_coder_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::BoxCoder>(GetArenaForAllocation());
    _impl_.box_coder_ = p;
  }
  return _impl_.box_coder_;
}
inline ::object_detection::protos::BoxCoder* Ssd::mutable_box_coder() {
  ::object_detection::protos::BoxCoder* _msg = _internal_mutable_box_coder();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.box_coder)
  return _msg;
}
inline void Ssd::set_allocated_box_coder(::object_detection::protos::BoxCoder* box_coder) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.box_coder_);
  }
  if (box_coder) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(box_coder));
    if (message_arena != submessage_arena) {
      box_coder = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, box_coder, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.box_coder_ = box_coder;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.box_coder)
}

// optional .object_detection.protos.Matcher matcher = 5;
inline bool Ssd::_internal_has_matcher() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.matcher_ != nullptr);
  return value;
}
inline bool Ssd::has_matcher() const {
  return _internal_has_matcher();
}
inline const ::object_detection::protos::Matcher& Ssd::_internal_matcher() const {
  const ::object_detection::protos::Matcher* p = _impl_.matcher_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Matcher&>(
      ::object_detection::protos::_Matcher_default_instance_);
}
inline const ::object_detection::protos::Matcher& Ssd::matcher() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.matcher)
  return _internal_matcher();
}
inline void Ssd::unsafe_arena_set_allocated_matcher(
    ::object_detection::protos::Matcher* matcher) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.matcher_);
  }
  _impl_.matcher_ = matcher;
  if (matcher) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.matcher)
}
inline ::object_detection::protos::Matcher* Ssd::release_matcher() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::object_detection::protos::Matcher* temp = _impl_.matcher_;
  _impl_.matcher_ = 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::Matcher* Ssd::unsafe_arena_release_matcher() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.matcher)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::object_detection::protos::Matcher* temp = _impl_.matcher_;
  _impl_.matcher_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Matcher* Ssd::_internal_mutable_matcher() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.matcher_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Matcher>(GetArenaForAllocation());
    _impl_.matcher_ = p;
  }
  return _impl_.matcher_;
}
inline ::object_detection::protos::Matcher* Ssd::mutable_matcher() {
  ::object_detection::protos::Matcher* _msg = _internal_mutable_matcher();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.matcher)
  return _msg;
}
inline void Ssd::set_allocated_matcher(::object_detection::protos::Matcher* matcher) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.matcher_);
  }
  if (matcher) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(matcher));
    if (message_arena != submessage_arena) {
      matcher = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, matcher, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.matcher_ = matcher;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.matcher)
}

// optional .object_detection.protos.RegionSimilarityCalculator similarity_calculator = 6;
inline bool Ssd::_internal_has_similarity_calculator() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.similarity_calculator_ != nullptr);
  return value;
}
inline bool Ssd::has_similarity_calculator() const {
  return _internal_has_similarity_calculator();
}
inline const ::object_detection::protos::RegionSimilarityCalculator& Ssd::_internal_similarity_calculator() const {
  const ::object_detection::protos::RegionSimilarityCalculator* p = _impl_.similarity_calculator_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::RegionSimilarityCalculator&>(
      ::object_detection::protos::_RegionSimilarityCalculator_default_instance_);
}
inline const ::object_detection::protos::RegionSimilarityCalculator& Ssd::similarity_calculator() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.similarity_calculator)
  return _internal_similarity_calculator();
}
inline void Ssd::unsafe_arena_set_allocated_similarity_calculator(
    ::object_detection::protos::RegionSimilarityCalculator* similarity_calculator) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.similarity_calculator_);
  }
  _impl_.similarity_calculator_ = similarity_calculator;
  if (similarity_calculator) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.similarity_calculator)
}
inline ::object_detection::protos::RegionSimilarityCalculator* Ssd::release_similarity_calculator() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::object_detection::protos::RegionSimilarityCalculator* temp = _impl_.similarity_calculator_;
  _impl_.similarity_calculator_ = 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::RegionSimilarityCalculator* Ssd::unsafe_arena_release_similarity_calculator() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.similarity_calculator)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::object_detection::protos::RegionSimilarityCalculator* temp = _impl_.similarity_calculator_;
  _impl_.similarity_calculator_ = nullptr;
  return temp;
}
inline ::object_detection::protos::RegionSimilarityCalculator* Ssd::_internal_mutable_similarity_calculator() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.similarity_calculator_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::RegionSimilarityCalculator>(GetArenaForAllocation());
    _impl_.similarity_calculator_ = p;
  }
  return _impl_.similarity_calculator_;
}
inline ::object_detection::protos::RegionSimilarityCalculator* Ssd::mutable_similarity_calculator() {
  ::object_detection::protos::RegionSimilarityCalculator* _msg = _internal_mutable_similarity_calculator();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.similarity_calculator)
  return _msg;
}
inline void Ssd::set_allocated_similarity_calculator(::object_detection::protos::RegionSimilarityCalculator* similarity_calculator) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.similarity_calculator_);
  }
  if (similarity_calculator) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(similarity_calculator));
    if (message_arena != submessage_arena) {
      similarity_calculator = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, similarity_calculator, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.similarity_calculator_ = similarity_calculator;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.similarity_calculator)
}

// optional bool encode_background_as_zeros = 12 [default = false];
inline bool Ssd::_internal_has_encode_background_as_zeros() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Ssd::has_encode_background_as_zeros() const {
  return _internal_has_encode_background_as_zeros();
}
inline void Ssd::clear_encode_background_as_zeros() {
  _impl_.encode_background_as_zeros_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool Ssd::_internal_encode_background_as_zeros() const {
  return _impl_.encode_background_as_zeros_;
}
inline bool Ssd::encode_background_as_zeros() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.encode_background_as_zeros)
  return _internal_encode_background_as_zeros();
}
inline void Ssd::_internal_set_encode_background_as_zeros(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.encode_background_as_zeros_ = value;
}
inline void Ssd::set_encode_background_as_zeros(bool value) {
  _internal_set_encode_background_as_zeros(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.encode_background_as_zeros)
}

// optional float negative_class_weight = 13 [default = 1];
inline bool Ssd::_internal_has_negative_class_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Ssd::has_negative_class_weight() const {
  return _internal_has_negative_class_weight();
}
inline void Ssd::clear_negative_class_weight() {
  _impl_.negative_class_weight_ = 1;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline float Ssd::_internal_negative_class_weight() const {
  return _impl_.negative_class_weight_;
}
inline float Ssd::negative_class_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.negative_class_weight)
  return _internal_negative_class_weight();
}
inline void Ssd::_internal_set_negative_class_weight(float value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.negative_class_weight_ = value;
}
inline void Ssd::set_negative_class_weight(float value) {
  _internal_set_negative_class_weight(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.negative_class_weight)
}

// optional .object_detection.protos.BoxPredictor box_predictor = 7;
inline bool Ssd::_internal_has_box_predictor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.box_predictor_ != nullptr);
  return value;
}
inline bool Ssd::has_box_predictor() const {
  return _internal_has_box_predictor();
}
inline const ::object_detection::protos::BoxPredictor& Ssd::_internal_box_predictor() const {
  const ::object_detection::protos::BoxPredictor* p = _impl_.box_predictor_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::BoxPredictor&>(
      ::object_detection::protos::_BoxPredictor_default_instance_);
}
inline const ::object_detection::protos::BoxPredictor& Ssd::box_predictor() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.box_predictor)
  return _internal_box_predictor();
}
inline void Ssd::unsafe_arena_set_allocated_box_predictor(
    ::object_detection::protos::BoxPredictor* box_predictor) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.box_predictor_);
  }
  _impl_.box_predictor_ = box_predictor;
  if (box_predictor) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.box_predictor)
}
inline ::object_detection::protos::BoxPredictor* Ssd::release_box_predictor() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::object_detection::protos::BoxPredictor* temp = _impl_.box_predictor_;
  _impl_.box_predictor_ = 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::BoxPredictor* Ssd::unsafe_arena_release_box_predictor() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.box_predictor)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::object_detection::protos::BoxPredictor* temp = _impl_.box_predictor_;
  _impl_.box_predictor_ = nullptr;
  return temp;
}
inline ::object_detection::protos::BoxPredictor* Ssd::_internal_mutable_box_predictor() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.box_predictor_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::BoxPredictor>(GetArenaForAllocation());
    _impl_.box_predictor_ = p;
  }
  return _impl_.box_predictor_;
}
inline ::object_detection::protos::BoxPredictor* Ssd::mutable_box_predictor() {
  ::object_detection::protos::BoxPredictor* _msg = _internal_mutable_box_predictor();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.box_predictor)
  return _msg;
}
inline void Ssd::set_allocated_box_predictor(::object_detection::protos::BoxPredictor* box_predictor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.box_predictor_);
  }
  if (box_predictor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(box_predictor));
    if (message_arena != submessage_arena) {
      box_predictor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, box_predictor, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.box_predictor_ = box_predictor;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.box_predictor)
}

// optional .object_detection.protos.AnchorGenerator anchor_generator = 8;
inline bool Ssd::_internal_has_anchor_generator() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.anchor_generator_ != nullptr);
  return value;
}
inline bool Ssd::has_anchor_generator() const {
  return _internal_has_anchor_generator();
}
inline const ::object_detection::protos::AnchorGenerator& Ssd::_internal_anchor_generator() const {
  const ::object_detection::protos::AnchorGenerator* p = _impl_.anchor_generator_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::AnchorGenerator&>(
      ::object_detection::protos::_AnchorGenerator_default_instance_);
}
inline const ::object_detection::protos::AnchorGenerator& Ssd::anchor_generator() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.anchor_generator)
  return _internal_anchor_generator();
}
inline void Ssd::unsafe_arena_set_allocated_anchor_generator(
    ::object_detection::protos::AnchorGenerator* anchor_generator) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.anchor_generator_);
  }
  _impl_.anchor_generator_ = anchor_generator;
  if (anchor_generator) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.anchor_generator)
}
inline ::object_detection::protos::AnchorGenerator* Ssd::release_anchor_generator() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::object_detection::protos::AnchorGenerator* temp = _impl_.anchor_generator_;
  _impl_.anchor_generator_ = 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::AnchorGenerator* Ssd::unsafe_arena_release_anchor_generator() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.anchor_generator)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::object_detection::protos::AnchorGenerator* temp = _impl_.anchor_generator_;
  _impl_.anchor_generator_ = nullptr;
  return temp;
}
inline ::object_detection::protos::AnchorGenerator* Ssd::_internal_mutable_anchor_generator() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.anchor_generator_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::AnchorGenerator>(GetArenaForAllocation());
    _impl_.anchor_generator_ = p;
  }
  return _impl_.anchor_generator_;
}
inline ::object_detection::protos::AnchorGenerator* Ssd::mutable_anchor_generator() {
  ::object_detection::protos::AnchorGenerator* _msg = _internal_mutable_anchor_generator();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.anchor_generator)
  return _msg;
}
inline void Ssd::set_allocated_anchor_generator(::object_detection::protos::AnchorGenerator* anchor_generator) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.anchor_generator_);
  }
  if (anchor_generator) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(anchor_generator));
    if (message_arena != submessage_arena) {
      anchor_generator = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, anchor_generator, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.anchor_generator_ = anchor_generator;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.anchor_generator)
}

// optional .object_detection.protos.PostProcessing post_processing = 9;
inline bool Ssd::_internal_has_post_processing() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.post_processing_ != nullptr);
  return value;
}
inline bool Ssd::has_post_processing() const {
  return _internal_has_post_processing();
}
inline const ::object_detection::protos::PostProcessing& Ssd::_internal_post_processing() const {
  const ::object_detection::protos::PostProcessing* p = _impl_.post_processing_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::PostProcessing&>(
      ::object_detection::protos::_PostProcessing_default_instance_);
}
inline const ::object_detection::protos::PostProcessing& Ssd::post_processing() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.post_processing)
  return _internal_post_processing();
}
inline void Ssd::unsafe_arena_set_allocated_post_processing(
    ::object_detection::protos::PostProcessing* post_processing) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.post_processing_);
  }
  _impl_.post_processing_ = post_processing;
  if (post_processing) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.post_processing)
}
inline ::object_detection::protos::PostProcessing* Ssd::release_post_processing() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::object_detection::protos::PostProcessing* temp = _impl_.post_processing_;
  _impl_.post_processing_ = 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::PostProcessing* Ssd::unsafe_arena_release_post_processing() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.post_processing)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::object_detection::protos::PostProcessing* temp = _impl_.post_processing_;
  _impl_.post_processing_ = nullptr;
  return temp;
}
inline ::object_detection::protos::PostProcessing* Ssd::_internal_mutable_post_processing() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.post_processing_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::PostProcessing>(GetArenaForAllocation());
    _impl_.post_processing_ = p;
  }
  return _impl_.post_processing_;
}
inline ::object_detection::protos::PostProcessing* Ssd::mutable_post_processing() {
  ::object_detection::protos::PostProcessing* _msg = _internal_mutable_post_processing();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.post_processing)
  return _msg;
}
inline void Ssd::set_allocated_post_processing(::object_detection::protos::PostProcessing* post_processing) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.post_processing_);
  }
  if (post_processing) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_processing));
    if (message_arena != submessage_arena) {
      post_processing = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, post_processing, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.post_processing_ = post_processing;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.post_processing)
}

// optional bool normalize_loss_by_num_matches = 10 [default = true];
inline bool Ssd::_internal_has_normalize_loss_by_num_matches() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Ssd::has_normalize_loss_by_num_matches() const {
  return _internal_has_normalize_loss_by_num_matches();
}
inline void Ssd::clear_normalize_loss_by_num_matches() {
  _impl_.normalize_loss_by_num_matches_ = true;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline bool Ssd::_internal_normalize_loss_by_num_matches() const {
  return _impl_.normalize_loss_by_num_matches_;
}
inline bool Ssd::normalize_loss_by_num_matches() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.normalize_loss_by_num_matches)
  return _internal_normalize_loss_by_num_matches();
}
inline void Ssd::_internal_set_normalize_loss_by_num_matches(bool value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.normalize_loss_by_num_matches_ = value;
}
inline void Ssd::set_normalize_loss_by_num_matches(bool value) {
  _internal_set_normalize_loss_by_num_matches(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.normalize_loss_by_num_matches)
}

// optional bool normalize_loc_loss_by_codesize = 14 [default = false];
inline bool Ssd::_internal_has_normalize_loc_loss_by_codesize() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Ssd::has_normalize_loc_loss_by_codesize() const {
  return _internal_has_normalize_loc_loss_by_codesize();
}
inline void Ssd::clear_normalize_loc_loss_by_codesize() {
  _impl_.normalize_loc_loss_by_codesize_ = false;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline bool Ssd::_internal_normalize_loc_loss_by_codesize() const {
  return _impl_.normalize_loc_loss_by_codesize_;
}
inline bool Ssd::normalize_loc_loss_by_codesize() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.normalize_loc_loss_by_codesize)
  return _internal_normalize_loc_loss_by_codesize();
}
inline void Ssd::_internal_set_normalize_loc_loss_by_codesize(bool value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.normalize_loc_loss_by_codesize_ = value;
}
inline void Ssd::set_normalize_loc_loss_by_codesize(bool value) {
  _internal_set_normalize_loc_loss_by_codesize(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.normalize_loc_loss_by_codesize)
}

// optional .object_detection.protos.Loss loss = 11;
inline bool Ssd::_internal_has_loss() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.loss_ != nullptr);
  return value;
}
inline bool Ssd::has_loss() const {
  return _internal_has_loss();
}
inline const ::object_detection::protos::Loss& Ssd::_internal_loss() const {
  const ::object_detection::protos::Loss* p = _impl_.loss_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Loss&>(
      ::object_detection::protos::_Loss_default_instance_);
}
inline const ::object_detection::protos::Loss& Ssd::loss() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.loss)
  return _internal_loss();
}
inline void Ssd::unsafe_arena_set_allocated_loss(
    ::object_detection::protos::Loss* loss) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.loss_);
  }
  _impl_.loss_ = loss;
  if (loss) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.loss)
}
inline ::object_detection::protos::Loss* Ssd::release_loss() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::object_detection::protos::Loss* temp = _impl_.loss_;
  _impl_.loss_ = 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::Loss* Ssd::unsafe_arena_release_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.loss)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::object_detection::protos::Loss* temp = _impl_.loss_;
  _impl_.loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Loss* Ssd::_internal_mutable_loss() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Loss>(GetArenaForAllocation());
    _impl_.loss_ = p;
  }
  return _impl_.loss_;
}
inline ::object_detection::protos::Loss* Ssd::mutable_loss() {
  ::object_detection::protos::Loss* _msg = _internal_mutable_loss();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.loss)
  return _msg;
}
inline void Ssd::set_allocated_loss(::object_detection::protos::Loss* loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.loss_);
  }
  if (loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(loss));
    if (message_arena != submessage_arena) {
      loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, loss, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.loss_ = loss;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.loss)
}

// optional bool freeze_batchnorm = 16 [default = false];
inline bool Ssd::_internal_has_freeze_batchnorm() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Ssd::has_freeze_batchnorm() const {
  return _internal_has_freeze_batchnorm();
}
inline void Ssd::clear_freeze_batchnorm() {
  _impl_.freeze_batchnorm_ = false;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline bool Ssd::_internal_freeze_batchnorm() const {
  return _impl_.freeze_batchnorm_;
}
inline bool Ssd::freeze_batchnorm() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.freeze_batchnorm)
  return _internal_freeze_batchnorm();
}
inline void Ssd::_internal_set_freeze_batchnorm(bool value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.freeze_batchnorm_ = value;
}
inline void Ssd::set_freeze_batchnorm(bool value) {
  _internal_set_freeze_batchnorm(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.freeze_batchnorm)
}

// optional bool inplace_batchnorm_update = 15 [default = false];
inline bool Ssd::_internal_has_inplace_batchnorm_update() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Ssd::has_inplace_batchnorm_update() const {
  return _internal_has_inplace_batchnorm_update();
}
inline void Ssd::clear_inplace_batchnorm_update() {
  _impl_.inplace_batchnorm_update_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool Ssd::_internal_inplace_batchnorm_update() const {
  return _impl_.inplace_batchnorm_update_;
}
inline bool Ssd::inplace_batchnorm_update() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.inplace_batchnorm_update)
  return _internal_inplace_batchnorm_update();
}
inline void Ssd::_internal_set_inplace_batchnorm_update(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.inplace_batchnorm_update_ = value;
}
inline void Ssd::set_inplace_batchnorm_update(bool value) {
  _internal_set_inplace_batchnorm_update(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.inplace_batchnorm_update)
}

// optional bool add_background_class = 21 [default = true];
inline bool Ssd::_internal_has_add_background_class() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool Ssd::has_add_background_class() const {
  return _internal_has_add_background_class();
}
inline void Ssd::clear_add_background_class() {
  _impl_.add_background_class_ = true;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline bool Ssd::_internal_add_background_class() const {
  return _impl_.add_background_class_;
}
inline bool Ssd::add_background_class() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.add_background_class)
  return _internal_add_background_class();
}
inline void Ssd::_internal_set_add_background_class(bool value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.add_background_class_ = value;
}
inline void Ssd::set_add_background_class(bool value) {
  _internal_set_add_background_class(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.add_background_class)
}

// optional bool explicit_background_class = 24 [default = false];
inline bool Ssd::_internal_has_explicit_background_class() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Ssd::has_explicit_background_class() const {
  return _internal_has_explicit_background_class();
}
inline void Ssd::clear_explicit_background_class() {
  _impl_.explicit_background_class_ = false;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline bool Ssd::_internal_explicit_background_class() const {
  return _impl_.explicit_background_class_;
}
inline bool Ssd::explicit_background_class() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.explicit_background_class)
  return _internal_explicit_background_class();
}
inline void Ssd::_internal_set_explicit_background_class(bool value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.explicit_background_class_ = value;
}
inline void Ssd::set_explicit_background_class(bool value) {
  _internal_set_explicit_background_class(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.explicit_background_class)
}

// optional bool use_confidences_as_targets = 22 [default = false];
inline bool Ssd::_internal_has_use_confidences_as_targets() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Ssd::has_use_confidences_as_targets() const {
  return _internal_has_use_confidences_as_targets();
}
inline void Ssd::clear_use_confidences_as_targets() {
  _impl_.use_confidences_as_targets_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool Ssd::_internal_use_confidences_as_targets() const {
  return _impl_.use_confidences_as_targets_;
}
inline bool Ssd::use_confidences_as_targets() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.use_confidences_as_targets)
  return _internal_use_confidences_as_targets();
}
inline void Ssd::_internal_set_use_confidences_as_targets(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.use_confidences_as_targets_ = value;
}
inline void Ssd::set_use_confidences_as_targets(bool value) {
  _internal_set_use_confidences_as_targets(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.use_confidences_as_targets)
}

// optional float implicit_example_weight = 23 [default = 1];
inline bool Ssd::_internal_has_implicit_example_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Ssd::has_implicit_example_weight() const {
  return _internal_has_implicit_example_weight();
}
inline void Ssd::clear_implicit_example_weight() {
  _impl_.implicit_example_weight_ = 1;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline float Ssd::_internal_implicit_example_weight() const {
  return _impl_.implicit_example_weight_;
}
inline float Ssd::implicit_example_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.implicit_example_weight)
  return _internal_implicit_example_weight();
}
inline void Ssd::_internal_set_implicit_example_weight(float value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.implicit_example_weight_ = value;
}
inline void Ssd::set_implicit_example_weight(float value) {
  _internal_set_implicit_example_weight(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Ssd.implicit_example_weight)
}

// optional .object_detection.protos.Ssd.MaskHead mask_head_config = 25;
inline bool Ssd::_internal_has_mask_head_config() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mask_head_config_ != nullptr);
  return value;
}
inline bool Ssd::has_mask_head_config() const {
  return _internal_has_mask_head_config();
}
inline void Ssd::clear_mask_head_config() {
  if (_impl_.mask_head_config_ != nullptr) _impl_.mask_head_config_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::object_detection::protos::Ssd_MaskHead& Ssd::_internal_mask_head_config() const {
  const ::object_detection::protos::Ssd_MaskHead* p = _impl_.mask_head_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Ssd_MaskHead&>(
      ::object_detection::protos::_Ssd_MaskHead_default_instance_);
}
inline const ::object_detection::protos::Ssd_MaskHead& Ssd::mask_head_config() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.mask_head_config)
  return _internal_mask_head_config();
}
inline void Ssd::unsafe_arena_set_allocated_mask_head_config(
    ::object_detection::protos::Ssd_MaskHead* mask_head_config) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mask_head_config_);
  }
  _impl_.mask_head_config_ = mask_head_config;
  if (mask_head_config) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Ssd.mask_head_config)
}
inline ::object_detection::protos::Ssd_MaskHead* Ssd::release_mask_head_config() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::object_detection::protos::Ssd_MaskHead* temp = _impl_.mask_head_config_;
  _impl_.mask_head_config_ = 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::Ssd_MaskHead* Ssd::unsafe_arena_release_mask_head_config() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.mask_head_config)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::object_detection::protos::Ssd_MaskHead* temp = _impl_.mask_head_config_;
  _impl_.mask_head_config_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Ssd_MaskHead* Ssd::_internal_mutable_mask_head_config() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.mask_head_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Ssd_MaskHead>(GetArenaForAllocation());
    _impl_.mask_head_config_ = p;
  }
  return _impl_.mask_head_config_;
}
inline ::object_detection::protos::Ssd_MaskHead* Ssd::mutable_mask_head_config() {
  ::object_detection::protos::Ssd_MaskHead* _msg = _internal_mutable_mask_head_config();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.mask_head_config)
  return _msg;
}
inline void Ssd::set_allocated_mask_head_config(::object_detection::protos::Ssd_MaskHead* mask_head_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.mask_head_config_;
  }
  if (mask_head_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mask_head_config);
    if (message_arena != submessage_arena) {
      mask_head_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mask_head_config, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.mask_head_config_ = mask_head_config;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.mask_head_config)
}

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

// SsdFeatureExtractor

// optional string type = 1;
inline bool SsdFeatureExtractor::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_type() const {
  return _internal_has_type();
}
inline void SsdFeatureExtractor::clear_type() {
  _impl_.type_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SsdFeatureExtractor::type() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SsdFeatureExtractor::set_type(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.type)
}
inline std::string* SsdFeatureExtractor::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SsdFeatureExtractor.type)
  return _s;
}
inline const std::string& SsdFeatureExtractor::_internal_type() const {
  return _impl_.type_.Get();
}
inline void SsdFeatureExtractor::_internal_set_type(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.type_.Set(value, GetArenaForAllocation());
}
inline std::string* SsdFeatureExtractor::_internal_mutable_type() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.type_.Mutable(GetArenaForAllocation());
}
inline std::string* SsdFeatureExtractor::release_type() {
  // @@protoc_insertion_point(field_release:object_detection.protos.SsdFeatureExtractor.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.type_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SsdFeatureExtractor::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.SsdFeatureExtractor.type)
}

// optional float depth_multiplier = 2 [default = 1];
inline bool SsdFeatureExtractor::_internal_has_depth_multiplier() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_depth_multiplier() const {
  return _internal_has_depth_multiplier();
}
inline void SsdFeatureExtractor::clear_depth_multiplier() {
  _impl_.depth_multiplier_ = 1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float SsdFeatureExtractor::_internal_depth_multiplier() const {
  return _impl_.depth_multiplier_;
}
inline float SsdFeatureExtractor::depth_multiplier() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.depth_multiplier)
  return _internal_depth_multiplier();
}
inline void SsdFeatureExtractor::_internal_set_depth_multiplier(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.depth_multiplier_ = value;
}
inline void SsdFeatureExtractor::set_depth_multiplier(float value) {
  _internal_set_depth_multiplier(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.depth_multiplier)
}

// optional int32 min_depth = 3 [default = 16];
inline bool SsdFeatureExtractor::_internal_has_min_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_min_depth() const {
  return _internal_has_min_depth();
}
inline void SsdFeatureExtractor::clear_min_depth() {
  _impl_.min_depth_ = 16;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t SsdFeatureExtractor::_internal_min_depth() const {
  return _impl_.min_depth_;
}
inline int32_t SsdFeatureExtractor::min_depth() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.min_depth)
  return _internal_min_depth();
}
inline void SsdFeatureExtractor::_internal_set_min_depth(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.min_depth_ = value;
}
inline void SsdFeatureExtractor::set_min_depth(int32_t value) {
  _internal_set_min_depth(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.min_depth)
}

// optional .object_detection.protos.Hyperparams conv_hyperparams = 4;
inline bool SsdFeatureExtractor::_internal_has_conv_hyperparams() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.conv_hyperparams_ != nullptr);
  return value;
}
inline bool SsdFeatureExtractor::has_conv_hyperparams() const {
  return _internal_has_conv_hyperparams();
}
inline const ::object_detection::protos::Hyperparams& SsdFeatureExtractor::_internal_conv_hyperparams() const {
  const ::object_detection::protos::Hyperparams* p = _impl_.conv_hyperparams_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Hyperparams&>(
      ::object_detection::protos::_Hyperparams_default_instance_);
}
inline const ::object_detection::protos::Hyperparams& SsdFeatureExtractor::conv_hyperparams() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
  return _internal_conv_hyperparams();
}
inline void SsdFeatureExtractor::unsafe_arena_set_allocated_conv_hyperparams(
    ::object_detection::protos::Hyperparams* conv_hyperparams) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.conv_hyperparams_);
  }
  _impl_.conv_hyperparams_ = conv_hyperparams;
  if (conv_hyperparams) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
}
inline ::object_detection::protos::Hyperparams* SsdFeatureExtractor::release_conv_hyperparams() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::Hyperparams* temp = _impl_.conv_hyperparams_;
  _impl_.conv_hyperparams_ = 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::Hyperparams* SsdFeatureExtractor::unsafe_arena_release_conv_hyperparams() {
  // @@protoc_insertion_point(field_release:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::Hyperparams* temp = _impl_.conv_hyperparams_;
  _impl_.conv_hyperparams_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Hyperparams* SsdFeatureExtractor::_internal_mutable_conv_hyperparams() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.conv_hyperparams_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Hyperparams>(GetArenaForAllocation());
    _impl_.conv_hyperparams_ = p;
  }
  return _impl_.conv_hyperparams_;
}
inline ::object_detection::protos::Hyperparams* SsdFeatureExtractor::mutable_conv_hyperparams() {
  ::object_detection::protos::Hyperparams* _msg = _internal_mutable_conv_hyperparams();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
  return _msg;
}
inline void SsdFeatureExtractor::set_allocated_conv_hyperparams(::object_detection::protos::Hyperparams* conv_hyperparams) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.conv_hyperparams_);
  }
  if (conv_hyperparams) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(conv_hyperparams));
    if (message_arena != submessage_arena) {
      conv_hyperparams = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, conv_hyperparams, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.conv_hyperparams_ = conv_hyperparams;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
}

// optional bool override_base_feature_extractor_hyperparams = 9 [default = false];
inline bool SsdFeatureExtractor::_internal_has_override_base_feature_extractor_hyperparams() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_override_base_feature_extractor_hyperparams() const {
  return _internal_has_override_base_feature_extractor_hyperparams();
}
inline void SsdFeatureExtractor::clear_override_base_feature_extractor_hyperparams() {
  _impl_.override_base_feature_extractor_hyperparams_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool SsdFeatureExtractor::_internal_override_base_feature_extractor_hyperparams() const {
  return _impl_.override_base_feature_extractor_hyperparams_;
}
inline bool SsdFeatureExtractor::override_base_feature_extractor_hyperparams() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.override_base_feature_extractor_hyperparams)
  return _internal_override_base_feature_extractor_hyperparams();
}
inline void SsdFeatureExtractor::_internal_set_override_base_feature_extractor_hyperparams(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.override_base_feature_extractor_hyperparams_ = value;
}
inline void SsdFeatureExtractor::set_override_base_feature_extractor_hyperparams(bool value) {
  _internal_set_override_base_feature_extractor_hyperparams(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.override_base_feature_extractor_hyperparams)
}

// optional int32 pad_to_multiple = 5 [default = 1];
inline bool SsdFeatureExtractor::_internal_has_pad_to_multiple() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_pad_to_multiple() const {
  return _internal_has_pad_to_multiple();
}
inline void SsdFeatureExtractor::clear_pad_to_multiple() {
  _impl_.pad_to_multiple_ = 1;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t SsdFeatureExtractor::_internal_pad_to_multiple() const {
  return _impl_.pad_to_multiple_;
}
inline int32_t SsdFeatureExtractor::pad_to_multiple() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.pad_to_multiple)
  return _internal_pad_to_multiple();
}
inline void SsdFeatureExtractor::_internal_set_pad_to_multiple(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.pad_to_multiple_ = value;
}
inline void SsdFeatureExtractor::set_pad_to_multiple(int32_t value) {
  _internal_set_pad_to_multiple(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.pad_to_multiple)
}

// optional bool use_explicit_padding = 7 [default = false];
inline bool SsdFeatureExtractor::_internal_has_use_explicit_padding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_use_explicit_padding() const {
  return _internal_has_use_explicit_padding();
}
inline void SsdFeatureExtractor::clear_use_explicit_padding() {
  _impl_.use_explicit_padding_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool SsdFeatureExtractor::_internal_use_explicit_padding() const {
  return _impl_.use_explicit_padding_;
}
inline bool SsdFeatureExtractor::use_explicit_padding() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.use_explicit_padding)
  return _internal_use_explicit_padding();
}
inline void SsdFeatureExtractor::_internal_set_use_explicit_padding(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.use_explicit_padding_ = value;
}
inline void SsdFeatureExtractor::set_use_explicit_padding(bool value) {
  _internal_set_use_explicit_padding(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.use_explicit_padding)
}

// optional bool use_depthwise = 8 [default = false];
inline bool SsdFeatureExtractor::_internal_has_use_depthwise() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_use_depthwise() const {
  return _internal_has_use_depthwise();
}
inline void SsdFeatureExtractor::clear_use_depthwise() {
  _impl_.use_depthwise_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool SsdFeatureExtractor::_internal_use_depthwise() const {
  return _impl_.use_depthwise_;
}
inline bool SsdFeatureExtractor::use_depthwise() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.use_depthwise)
  return _internal_use_depthwise();
}
inline void SsdFeatureExtractor::_internal_set_use_depthwise(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.use_depthwise_ = value;
}
inline void SsdFeatureExtractor::set_use_depthwise(bool value) {
  _internal_set_use_depthwise(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.use_depthwise)
}

// optional .object_detection.protos.FeaturePyramidNetworks fpn = 10;
inline bool SsdFeatureExtractor::_internal_has_fpn() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fpn_ != nullptr);
  return value;
}
inline bool SsdFeatureExtractor::has_fpn() const {
  return _internal_has_fpn();
}
inline void SsdFeatureExtractor::clear_fpn() {
  if (_impl_.fpn_ != nullptr) _impl_.fpn_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::object_detection::protos::FeaturePyramidNetworks& SsdFeatureExtractor::_internal_fpn() const {
  const ::object_detection::protos::FeaturePyramidNetworks* p = _impl_.fpn_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::FeaturePyramidNetworks&>(
      ::object_detection::protos::_FeaturePyramidNetworks_default_instance_);
}
inline const ::object_detection::protos::FeaturePyramidNetworks& SsdFeatureExtractor::fpn() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.fpn)
  return _internal_fpn();
}
inline void SsdFeatureExtractor::unsafe_arena_set_allocated_fpn(
    ::object_detection::protos::FeaturePyramidNetworks* fpn) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fpn_);
  }
  _impl_.fpn_ = fpn;
  if (fpn) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.SsdFeatureExtractor.fpn)
}
inline ::object_detection::protos::FeaturePyramidNetworks* SsdFeatureExtractor::release_fpn() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::FeaturePyramidNetworks* temp = _impl_.fpn_;
  _impl_.fpn_ = 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::FeaturePyramidNetworks* SsdFeatureExtractor::unsafe_arena_release_fpn() {
  // @@protoc_insertion_point(field_release:object_detection.protos.SsdFeatureExtractor.fpn)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::FeaturePyramidNetworks* temp = _impl_.fpn_;
  _impl_.fpn_ = nullptr;
  return temp;
}
inline ::object_detection::protos::FeaturePyramidNetworks* SsdFeatureExtractor::_internal_mutable_fpn() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.fpn_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::FeaturePyramidNetworks>(GetArenaForAllocation());
    _impl_.fpn_ = p;
  }
  return _impl_.fpn_;
}
inline ::object_detection::protos::FeaturePyramidNetworks* SsdFeatureExtractor::mutable_fpn() {
  ::object_detection::protos::FeaturePyramidNetworks* _msg = _internal_mutable_fpn();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SsdFeatureExtractor.fpn)
  return _msg;
}
inline void SsdFeatureExtractor::set_allocated_fpn(::object_detection::protos::FeaturePyramidNetworks* fpn) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.fpn_;
  }
  if (fpn) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fpn);
    if (message_arena != submessage_arena) {
      fpn = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fpn, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fpn_ = fpn;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.SsdFeatureExtractor.fpn)
}

// optional bool replace_preprocessor_with_placeholder = 11 [default = false];
inline bool SsdFeatureExtractor::_internal_has_replace_preprocessor_with_placeholder() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_replace_preprocessor_with_placeholder() const {
  return _internal_has_replace_preprocessor_with_placeholder();
}
inline void SsdFeatureExtractor::clear_replace_preprocessor_with_placeholder() {
  _impl_.replace_preprocessor_with_placeholder_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool SsdFeatureExtractor::_internal_replace_preprocessor_with_placeholder() const {
  return _impl_.replace_preprocessor_with_placeholder_;
}
inline bool SsdFeatureExtractor::replace_preprocessor_with_placeholder() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.replace_preprocessor_with_placeholder)
  return _internal_replace_preprocessor_with_placeholder();
}
inline void SsdFeatureExtractor::_internal_set_replace_preprocessor_with_placeholder(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.replace_preprocessor_with_placeholder_ = value;
}
inline void SsdFeatureExtractor::set_replace_preprocessor_with_placeholder(bool value) {
  _internal_set_replace_preprocessor_with_placeholder(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.replace_preprocessor_with_placeholder)
}

// optional int32 num_layers = 12 [default = 6];
inline bool SsdFeatureExtractor::_internal_has_num_layers() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool SsdFeatureExtractor::has_num_layers() const {
  return _internal_has_num_layers();
}
inline void SsdFeatureExtractor::clear_num_layers() {
  _impl_.num_layers_ = 6;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int32_t SsdFeatureExtractor::_internal_num_layers() const {
  return _impl_.num_layers_;
}
inline int32_t SsdFeatureExtractor::num_layers() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.num_layers)
  return _internal_num_layers();
}
inline void SsdFeatureExtractor::_internal_set_num_layers(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.num_layers_ = value;
}
inline void SsdFeatureExtractor::set_num_layers(int32_t value) {
  _internal_set_num_layers(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.num_layers)
}

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

// FeaturePyramidNetworks

// optional int32 min_level = 1 [default = 3];
inline bool FeaturePyramidNetworks::_internal_has_min_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool FeaturePyramidNetworks::has_min_level() const {
  return _internal_has_min_level();
}
inline void FeaturePyramidNetworks::clear_min_level() {
  _impl_.min_level_ = 3;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t FeaturePyramidNetworks::_internal_min_level() const {
  return _impl_.min_level_;
}
inline int32_t FeaturePyramidNetworks::min_level() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.FeaturePyramidNetworks.min_level)
  return _internal_min_level();
}
inline void FeaturePyramidNetworks::_internal_set_min_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.min_level_ = value;
}
inline void FeaturePyramidNetworks::set_min_level(int32_t value) {
  _internal_set_min_level(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.FeaturePyramidNetworks.min_level)
}

// optional int32 max_level = 2 [default = 7];
inline bool FeaturePyramidNetworks::_internal_has_max_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool FeaturePyramidNetworks::has_max_level() const {
  return _internal_has_max_level();
}
inline void FeaturePyramidNetworks::clear_max_level() {
  _impl_.max_level_ = 7;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t FeaturePyramidNetworks::_internal_max_level() const {
  return _impl_.max_level_;
}
inline int32_t FeaturePyramidNetworks::max_level() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.FeaturePyramidNetworks.max_level)
  return _internal_max_level();
}
inline void FeaturePyramidNetworks::_internal_set_max_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_level_ = value;
}
inline void FeaturePyramidNetworks::set_max_level(int32_t value) {
  _internal_set_max_level(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.FeaturePyramidNetworks.max_level)
}

// optional int32 additional_layer_depth = 3 [default = 256];
inline bool FeaturePyramidNetworks::_internal_has_additional_layer_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool FeaturePyramidNetworks::has_additional_layer_depth() const {
  return _internal_has_additional_layer_depth();
}
inline void FeaturePyramidNetworks::clear_additional_layer_depth() {
  _impl_.additional_layer_depth_ = 256;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t FeaturePyramidNetworks::_internal_additional_layer_depth() const {
  return _impl_.additional_layer_depth_;
}
inline int32_t FeaturePyramidNetworks::additional_layer_depth() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.FeaturePyramidNetworks.additional_layer_depth)
  return _internal_additional_layer_depth();
}
inline void FeaturePyramidNetworks::_internal_set_additional_layer_depth(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.additional_layer_depth_ = value;
}
inline void FeaturePyramidNetworks::set_additional_layer_depth(int32_t value) {
  _internal_set_additional_layer_depth(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.FeaturePyramidNetworks.additional_layer_depth)
}

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace object_detection

// @@protoc_insertion_point(global_scope)

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