// 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 < 3009000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/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 ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_object_5fdetection_2fprotos_2fssd_2eproto;
namespace object_detection {
namespace protos {
class FeaturePyramidNetworks;
class FeaturePyramidNetworksDefaultTypeInternal;
extern FeaturePyramidNetworksDefaultTypeInternal _FeaturePyramidNetworks_default_instance_;
class Ssd;
class SsdDefaultTypeInternal;
extern SsdDefaultTypeInternal _Ssd_default_instance_;
class SsdFeatureExtractor;
class SsdFeatureExtractorDefaultTypeInternal;
extern SsdFeatureExtractorDefaultTypeInternal _SsdFeatureExtractor_default_instance_;
class Ssd_MaskHead;
class 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 :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.Ssd.MaskHead) */ {
 public:
  Ssd_MaskHead();
  virtual ~Ssd_MaskHead();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  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;
    InternalSwap(other);
  }

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

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

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

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

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

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

  public:

  // 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;
  void clear_conv_hyperparams();
  const ::object_detection::protos::Hyperparams& conv_hyperparams() const;
  ::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);

  // optional bool convolve_then_upsample_masks = 6 [default = false];
  bool has_convolve_then_upsample_masks() const;
  void clear_convolve_then_upsample_masks();
  bool convolve_then_upsample_masks() const;
  void set_convolve_then_upsample_masks(bool value);

  // optional int32 mask_height = 1 [default = 15];
  bool has_mask_height() const;
  void clear_mask_height();
  ::PROTOBUF_NAMESPACE_ID::int32 mask_height() const;
  void set_mask_height(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 mask_width = 2 [default = 15];
  bool has_mask_width() const;
  void clear_mask_width();
  ::PROTOBUF_NAMESPACE_ID::int32 mask_width() const;
  void set_mask_width(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool masks_are_class_agnostic = 3 [default = true];
  bool has_masks_are_class_agnostic() const;
  void clear_masks_are_class_agnostic();
  bool masks_are_class_agnostic() const;
  void set_masks_are_class_agnostic(bool value);

  // optional int32 mask_prediction_conv_depth = 4 [default = 256];
  bool has_mask_prediction_conv_depth() const;
  void clear_mask_prediction_conv_depth();
  ::PROTOBUF_NAMESPACE_ID::int32 mask_prediction_conv_depth() const;
  void set_mask_prediction_conv_depth(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 mask_prediction_num_conv_layers = 5 [default = 2];
  bool has_mask_prediction_num_conv_layers() const;
  void clear_mask_prediction_num_conv_layers();
  ::PROTOBUF_NAMESPACE_ID::int32 mask_prediction_num_conv_layers() const;
  void set_mask_prediction_num_conv_layers(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional float mask_loss_weight = 7 [default = 5];
  bool has_mask_loss_weight() const;
  void clear_mask_loss_weight();
  float mask_loss_weight() const;
  void set_mask_loss_weight(float value);

  // optional int32 mask_loss_sample_size = 8 [default = 16];
  bool has_mask_loss_sample_size() const;
  void clear_mask_loss_sample_size();
  ::PROTOBUF_NAMESPACE_ID::int32 mask_loss_sample_size() const;
  void set_mask_loss_sample_size(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 initial_crop_size = 10 [default = 15];
  bool has_initial_crop_size() const;
  void clear_initial_crop_size();
  ::PROTOBUF_NAMESPACE_ID::int32 initial_crop_size() const;
  void set_initial_crop_size(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::object_detection::protos::Hyperparams* conv_hyperparams_;
  bool convolve_then_upsample_masks_;
  ::PROTOBUF_NAMESPACE_ID::int32 mask_height_;
  ::PROTOBUF_NAMESPACE_ID::int32 mask_width_;
  bool masks_are_class_agnostic_;
  ::PROTOBUF_NAMESPACE_ID::int32 mask_prediction_conv_depth_;
  ::PROTOBUF_NAMESPACE_ID::int32 mask_prediction_num_conv_layers_;
  float mask_loss_weight_;
  ::PROTOBUF_NAMESPACE_ID::int32 mask_loss_sample_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 initial_crop_size_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fssd_2eproto;
};
// -------------------------------------------------------------------

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

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  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;
    InternalSwap(other);
  }

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

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

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

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

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

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

  public:

  // 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;
  void clear_image_resizer();
  const ::object_detection::protos::ImageResizer& image_resizer() const;
  ::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);

  // optional .object_detection.protos.SsdFeatureExtractor feature_extractor = 3;
  bool has_feature_extractor() const;
  void clear_feature_extractor();
  const ::object_detection::protos::SsdFeatureExtractor& feature_extractor() const;
  ::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);

  // optional .object_detection.protos.BoxCoder box_coder = 4;
  bool has_box_coder() const;
  void clear_box_coder();
  const ::object_detection::protos::BoxCoder& box_coder() const;
  ::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);

  // optional .object_detection.protos.Matcher matcher = 5;
  bool has_matcher() const;
  void clear_matcher();
  const ::object_detection::protos::Matcher& matcher() const;
  ::object_detection::protos::Matcher* release_matcher();
  ::object_detection::protos::Matcher* mutable_matcher();
  void set_allocated_matcher(::object_detection::protos::Matcher* matcher);

  // optional .object_detection.protos.RegionSimilarityCalculator similarity_calculator = 6;
  bool has_similarity_calculator() const;
  void clear_similarity_calculator();
  const ::object_detection::protos::RegionSimilarityCalculator& similarity_calculator() const;
  ::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);

  // optional .object_detection.protos.BoxPredictor box_predictor = 7;
  bool has_box_predictor() const;
  void clear_box_predictor();
  const ::object_detection::protos::BoxPredictor& box_predictor() const;
  ::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);

  // optional .object_detection.protos.AnchorGenerator anchor_generator = 8;
  bool has_anchor_generator() const;
  void clear_anchor_generator();
  const ::object_detection::protos::AnchorGenerator& anchor_generator() const;
  ::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);

  // optional .object_detection.protos.PostProcessing post_processing = 9;
  bool has_post_processing() const;
  void clear_post_processing();
  const ::object_detection::protos::PostProcessing& post_processing() const;
  ::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);

  // optional .object_detection.protos.Loss loss = 11;
  bool has_loss() const;
  void clear_loss();
  const ::object_detection::protos::Loss& loss() const;
  ::object_detection::protos::Loss* release_loss();
  ::object_detection::protos::Loss* mutable_loss();
  void set_allocated_loss(::object_detection::protos::Loss* loss);

  // optional .object_detection.protos.Ssd.MaskHead mask_head_config = 25;
  bool has_mask_head_config() const;
  void clear_mask_head_config();
  const ::object_detection::protos::Ssd_MaskHead& mask_head_config() const;
  ::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);

  // optional int32 num_classes = 1;
  bool has_num_classes() const;
  void clear_num_classes();
  ::PROTOBUF_NAMESPACE_ID::int32 num_classes() const;
  void set_num_classes(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool encode_background_as_zeros = 12 [default = false];
  bool has_encode_background_as_zeros() const;
  void clear_encode_background_as_zeros();
  bool encode_background_as_zeros() const;
  void set_encode_background_as_zeros(bool value);

  // optional bool normalize_loc_loss_by_codesize = 14 [default = false];
  bool has_normalize_loc_loss_by_codesize() const;
  void clear_normalize_loc_loss_by_codesize();
  bool normalize_loc_loss_by_codesize() const;
  void set_normalize_loc_loss_by_codesize(bool value);

  // optional bool freeze_batchnorm = 16 [default = false];
  bool has_freeze_batchnorm() const;
  void clear_freeze_batchnorm();
  bool freeze_batchnorm() const;
  void set_freeze_batchnorm(bool value);

  // optional bool inplace_batchnorm_update = 15 [default = false];
  bool has_inplace_batchnorm_update() const;
  void clear_inplace_batchnorm_update();
  bool inplace_batchnorm_update() const;
  void set_inplace_batchnorm_update(bool value);

  // optional bool explicit_background_class = 24 [default = false];
  bool has_explicit_background_class() const;
  void clear_explicit_background_class();
  bool explicit_background_class() const;
  void set_explicit_background_class(bool value);

  // optional bool use_confidences_as_targets = 22 [default = false];
  bool has_use_confidences_as_targets() const;
  void clear_use_confidences_as_targets();
  bool use_confidences_as_targets() const;
  void set_use_confidences_as_targets(bool value);

  // optional float implicit_example_weight = 23 [default = 1];
  bool has_implicit_example_weight() const;
  void clear_implicit_example_weight();
  float implicit_example_weight() const;
  void set_implicit_example_weight(float value);

  // optional float negative_class_weight = 13 [default = 1];
  bool has_negative_class_weight() const;
  void clear_negative_class_weight();
  float negative_class_weight() const;
  void set_negative_class_weight(float value);

  // optional bool normalize_loss_by_num_matches = 10 [default = true];
  bool has_normalize_loss_by_num_matches() const;
  void clear_normalize_loss_by_num_matches();
  bool normalize_loss_by_num_matches() const;
  void set_normalize_loss_by_num_matches(bool value);

  // optional bool add_background_class = 21 [default = true];
  bool has_add_background_class() const;
  void clear_add_background_class();
  bool add_background_class() const;
  void set_add_background_class(bool value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::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_;
  ::PROTOBUF_NAMESPACE_ID::int32 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_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fssd_2eproto;
};
// -------------------------------------------------------------------

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

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  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;
    InternalSwap(other);
  }

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

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

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

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

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

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

  public:

  // 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;
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);

  // optional .object_detection.protos.Hyperparams conv_hyperparams = 4;
  bool has_conv_hyperparams() const;
  void clear_conv_hyperparams();
  const ::object_detection::protos::Hyperparams& conv_hyperparams() const;
  ::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);

  // optional .object_detection.protos.FeaturePyramidNetworks fpn = 10;
  bool has_fpn() const;
  void clear_fpn();
  const ::object_detection::protos::FeaturePyramidNetworks& fpn() const;
  ::object_detection::protos::FeaturePyramidNetworks* release_fpn();
  ::object_detection::protos::FeaturePyramidNetworks* mutable_fpn();
  void set_allocated_fpn(::object_detection::protos::FeaturePyramidNetworks* fpn);

  // optional bool override_base_feature_extractor_hyperparams = 9 [default = false];
  bool has_override_base_feature_extractor_hyperparams() const;
  void clear_override_base_feature_extractor_hyperparams();
  bool override_base_feature_extractor_hyperparams() const;
  void set_override_base_feature_extractor_hyperparams(bool value);

  // optional bool use_explicit_padding = 7 [default = false];
  bool has_use_explicit_padding() const;
  void clear_use_explicit_padding();
  bool use_explicit_padding() const;
  void set_use_explicit_padding(bool value);

  // optional bool use_depthwise = 8 [default = false];
  bool has_use_depthwise() const;
  void clear_use_depthwise();
  bool use_depthwise() const;
  void set_use_depthwise(bool value);

  // optional bool replace_preprocessor_with_placeholder = 11 [default = false];
  bool has_replace_preprocessor_with_placeholder() const;
  void clear_replace_preprocessor_with_placeholder();
  bool replace_preprocessor_with_placeholder() const;
  void set_replace_preprocessor_with_placeholder(bool value);

  // optional float depth_multiplier = 2 [default = 1];
  bool has_depth_multiplier() const;
  void clear_depth_multiplier();
  float depth_multiplier() const;
  void set_depth_multiplier(float value);

  // optional int32 min_depth = 3 [default = 16];
  bool has_min_depth() const;
  void clear_min_depth();
  ::PROTOBUF_NAMESPACE_ID::int32 min_depth() const;
  void set_min_depth(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 pad_to_multiple = 5 [default = 1];
  bool has_pad_to_multiple() const;
  void clear_pad_to_multiple();
  ::PROTOBUF_NAMESPACE_ID::int32 pad_to_multiple() const;
  void set_pad_to_multiple(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 num_layers = 12 [default = 6];
  bool has_num_layers() const;
  void clear_num_layers();
  ::PROTOBUF_NAMESPACE_ID::int32 num_layers() const;
  void set_num_layers(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::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_;
  ::PROTOBUF_NAMESPACE_ID::int32 min_depth_;
  ::PROTOBUF_NAMESPACE_ID::int32 pad_to_multiple_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_layers_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2fssd_2eproto;
};
// -------------------------------------------------------------------

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

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  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;
    InternalSwap(other);
  }

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

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

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

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

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

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

  public:

  // 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;
  void clear_additional_layer_depth();
  ::PROTOBUF_NAMESPACE_ID::int32 additional_layer_depth() const;
  void set_additional_layer_depth(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 min_level = 1 [default = 3];
  bool has_min_level() const;
  void clear_min_level();
  ::PROTOBUF_NAMESPACE_ID::int32 min_level() const;
  void set_min_level(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 max_level = 2 [default = 7];
  bool has_max_level() const;
  void clear_max_level();
  ::PROTOBUF_NAMESPACE_ID::int32 max_level() const;
  void set_max_level(::PROTOBUF_NAMESPACE_ID::int32 value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 additional_layer_depth_;
  ::PROTOBUF_NAMESPACE_ID::int32 min_level_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_level_;
  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::has_mask_height() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Ssd_MaskHead::clear_mask_height() {
  mask_height_ = 15;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Ssd_MaskHead::mask_height() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_height)
  return mask_height_;
}
inline void Ssd_MaskHead::set_mask_height(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  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::has_mask_width() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Ssd_MaskHead::clear_mask_width() {
  mask_width_ = 15;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Ssd_MaskHead::mask_width() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_width)
  return mask_width_;
}
inline void Ssd_MaskHead::set_mask_width(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  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::has_masks_are_class_agnostic() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Ssd_MaskHead::clear_masks_are_class_agnostic() {
  masks_are_class_agnostic_ = true;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool Ssd_MaskHead::masks_are_class_agnostic() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.masks_are_class_agnostic)
  return masks_are_class_agnostic_;
}
inline void Ssd_MaskHead::set_masks_are_class_agnostic(bool value) {
  _has_bits_[0] |= 0x00000010u;
  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::has_mask_prediction_conv_depth() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Ssd_MaskHead::clear_mask_prediction_conv_depth() {
  mask_prediction_conv_depth_ = 256;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Ssd_MaskHead::mask_prediction_conv_depth() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_prediction_conv_depth)
  return mask_prediction_conv_depth_;
}
inline void Ssd_MaskHead::set_mask_prediction_conv_depth(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000020u;
  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::has_mask_prediction_num_conv_layers() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Ssd_MaskHead::clear_mask_prediction_num_conv_layers() {
  mask_prediction_num_conv_layers_ = 2;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Ssd_MaskHead::mask_prediction_num_conv_layers() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_prediction_num_conv_layers)
  return mask_prediction_num_conv_layers_;
}
inline void Ssd_MaskHead::set_mask_prediction_num_conv_layers(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000040u;
  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::has_convolve_then_upsample_masks() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Ssd_MaskHead::clear_convolve_then_upsample_masks() {
  convolve_then_upsample_masks_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool Ssd_MaskHead::convolve_then_upsample_masks() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.convolve_then_upsample_masks)
  return convolve_then_upsample_masks_;
}
inline void Ssd_MaskHead::set_convolve_then_upsample_masks(bool value) {
  _has_bits_[0] |= 0x00000002u;
  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::has_mask_loss_weight() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Ssd_MaskHead::clear_mask_loss_weight() {
  mask_loss_weight_ = 5;
  _has_bits_[0] &= ~0x00000080u;
}
inline float Ssd_MaskHead::mask_loss_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_loss_weight)
  return mask_loss_weight_;
}
inline void Ssd_MaskHead::set_mask_loss_weight(float value) {
  _has_bits_[0] |= 0x00000080u;
  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::has_mask_loss_sample_size() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Ssd_MaskHead::clear_mask_loss_sample_size() {
  mask_loss_sample_size_ = 16;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Ssd_MaskHead::mask_loss_sample_size() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.mask_loss_sample_size)
  return mask_loss_sample_size_;
}
inline void Ssd_MaskHead::set_mask_loss_sample_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000100u;
  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::has_conv_hyperparams() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline const ::object_detection::protos::Hyperparams& Ssd_MaskHead::conv_hyperparams() const {
  const ::object_detection::protos::Hyperparams* p = conv_hyperparams_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Hyperparams*>(
      &::object_detection::protos::_Hyperparams_default_instance_);
}
inline ::object_detection::protos::Hyperparams* Ssd_MaskHead::release_conv_hyperparams() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
  _has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::Hyperparams* temp = conv_hyperparams_;
  conv_hyperparams_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Hyperparams* Ssd_MaskHead::mutable_conv_hyperparams() {
  _has_bits_[0] |= 0x00000001u;
  if (conv_hyperparams_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Hyperparams>(GetArenaNoVirtual());
    conv_hyperparams_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.MaskHead.conv_hyperparams)
  return conv_hyperparams_;
}
inline void Ssd_MaskHead::set_allocated_conv_hyperparams(::object_detection::protos::Hyperparams* conv_hyperparams) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(conv_hyperparams_);
  }
  if (conv_hyperparams) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      conv_hyperparams = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, conv_hyperparams, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  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::has_initial_crop_size() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Ssd_MaskHead::clear_initial_crop_size() {
  initial_crop_size_ = 15;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Ssd_MaskHead::initial_crop_size() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.MaskHead.initial_crop_size)
  return initial_crop_size_;
}
inline void Ssd_MaskHead::set_initial_crop_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000200u;
  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::has_num_classes() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Ssd::clear_num_classes() {
  num_classes_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Ssd::num_classes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.num_classes)
  return num_classes_;
}
inline void Ssd::set_num_classes(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000400u;
  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::has_image_resizer() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline const ::object_detection::protos::ImageResizer& Ssd::image_resizer() const {
  const ::object_detection::protos::ImageResizer* p = image_resizer_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.image_resizer)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::ImageResizer*>(
      &::object_detection::protos::_ImageResizer_default_instance_);
}
inline ::object_detection::protos::ImageResizer* Ssd::release_image_resizer() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.image_resizer)
  _has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::ImageResizer* temp = image_resizer_;
  image_resizer_ = nullptr;
  return temp;
}
inline ::object_detection::protos::ImageResizer* Ssd::mutable_image_resizer() {
  _has_bits_[0] |= 0x00000001u;
  if (image_resizer_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::ImageResizer>(GetArenaNoVirtual());
    image_resizer_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.image_resizer)
  return image_resizer_;
}
inline void Ssd::set_allocated_image_resizer(::object_detection::protos::ImageResizer* image_resizer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(image_resizer_);
  }
  if (image_resizer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      image_resizer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, image_resizer, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  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::has_feature_extractor() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Ssd::clear_feature_extractor() {
  if (feature_extractor_ != nullptr) feature_extractor_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::object_detection::protos::SsdFeatureExtractor& Ssd::feature_extractor() const {
  const ::object_detection::protos::SsdFeatureExtractor* p = feature_extractor_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.feature_extractor)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::SsdFeatureExtractor*>(
      &::object_detection::protos::_SsdFeatureExtractor_default_instance_);
}
inline ::object_detection::protos::SsdFeatureExtractor* Ssd::release_feature_extractor() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.feature_extractor)
  _has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::SsdFeatureExtractor* temp = feature_extractor_;
  feature_extractor_ = nullptr;
  return temp;
}
inline ::object_detection::protos::SsdFeatureExtractor* Ssd::mutable_feature_extractor() {
  _has_bits_[0] |= 0x00000002u;
  if (feature_extractor_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::SsdFeatureExtractor>(GetArenaNoVirtual());
    feature_extractor_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.feature_extractor)
  return feature_extractor_;
}
inline void Ssd::set_allocated_feature_extractor(::object_detection::protos::SsdFeatureExtractor* feature_extractor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete feature_extractor_;
  }
  if (feature_extractor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      feature_extractor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, feature_extractor, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  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::has_box_coder() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline const ::object_detection::protos::BoxCoder& Ssd::box_coder() const {
  const ::object_detection::protos::BoxCoder* p = box_coder_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.box_coder)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::BoxCoder*>(
      &::object_detection::protos::_BoxCoder_default_instance_);
}
inline ::object_detection::protos::BoxCoder* Ssd::release_box_coder() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.box_coder)
  _has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::BoxCoder* temp = box_coder_;
  box_coder_ = nullptr;
  return temp;
}
inline ::object_detection::protos::BoxCoder* Ssd::mutable_box_coder() {
  _has_bits_[0] |= 0x00000004u;
  if (box_coder_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::BoxCoder>(GetArenaNoVirtual());
    box_coder_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.box_coder)
  return box_coder_;
}
inline void Ssd::set_allocated_box_coder(::object_detection::protos::BoxCoder* box_coder) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(box_coder_);
  }
  if (box_coder) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      box_coder = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, box_coder, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  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::has_matcher() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline const ::object_detection::protos::Matcher& Ssd::matcher() const {
  const ::object_detection::protos::Matcher* p = matcher_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.matcher)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Matcher*>(
      &::object_detection::protos::_Matcher_default_instance_);
}
inline ::object_detection::protos::Matcher* Ssd::release_matcher() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.matcher)
  _has_bits_[0] &= ~0x00000008u;
  ::object_detection::protos::Matcher* temp = matcher_;
  matcher_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Matcher* Ssd::mutable_matcher() {
  _has_bits_[0] |= 0x00000008u;
  if (matcher_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Matcher>(GetArenaNoVirtual());
    matcher_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.matcher)
  return matcher_;
}
inline void Ssd::set_allocated_matcher(::object_detection::protos::Matcher* matcher) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(matcher_);
  }
  if (matcher) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      matcher = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, matcher, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  matcher_ = matcher;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.matcher)
}

// optional .object_detection.protos.RegionSimilarityCalculator similarity_calculator = 6;
inline bool Ssd::has_similarity_calculator() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline const ::object_detection::protos::RegionSimilarityCalculator& Ssd::similarity_calculator() const {
  const ::object_detection::protos::RegionSimilarityCalculator* p = similarity_calculator_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.similarity_calculator)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::RegionSimilarityCalculator*>(
      &::object_detection::protos::_RegionSimilarityCalculator_default_instance_);
}
inline ::object_detection::protos::RegionSimilarityCalculator* Ssd::release_similarity_calculator() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.similarity_calculator)
  _has_bits_[0] &= ~0x00000010u;
  ::object_detection::protos::RegionSimilarityCalculator* temp = similarity_calculator_;
  similarity_calculator_ = nullptr;
  return temp;
}
inline ::object_detection::protos::RegionSimilarityCalculator* Ssd::mutable_similarity_calculator() {
  _has_bits_[0] |= 0x00000010u;
  if (similarity_calculator_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::RegionSimilarityCalculator>(GetArenaNoVirtual());
    similarity_calculator_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.similarity_calculator)
  return similarity_calculator_;
}
inline void Ssd::set_allocated_similarity_calculator(::object_detection::protos::RegionSimilarityCalculator* similarity_calculator) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(similarity_calculator_);
  }
  if (similarity_calculator) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      similarity_calculator = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, similarity_calculator, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  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::has_encode_background_as_zeros() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Ssd::clear_encode_background_as_zeros() {
  encode_background_as_zeros_ = false;
  _has_bits_[0] &= ~0x00000800u;
}
inline bool Ssd::encode_background_as_zeros() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.encode_background_as_zeros)
  return encode_background_as_zeros_;
}
inline void Ssd::set_encode_background_as_zeros(bool value) {
  _has_bits_[0] |= 0x00000800u;
  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::has_negative_class_weight() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void Ssd::clear_negative_class_weight() {
  negative_class_weight_ = 1;
  _has_bits_[0] &= ~0x00040000u;
}
inline float Ssd::negative_class_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.negative_class_weight)
  return negative_class_weight_;
}
inline void Ssd::set_negative_class_weight(float value) {
  _has_bits_[0] |= 0x00040000u;
  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::has_box_predictor() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline const ::object_detection::protos::BoxPredictor& Ssd::box_predictor() const {
  const ::object_detection::protos::BoxPredictor* p = box_predictor_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.box_predictor)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::BoxPredictor*>(
      &::object_detection::protos::_BoxPredictor_default_instance_);
}
inline ::object_detection::protos::BoxPredictor* Ssd::release_box_predictor() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.box_predictor)
  _has_bits_[0] &= ~0x00000020u;
  ::object_detection::protos::BoxPredictor* temp = box_predictor_;
  box_predictor_ = nullptr;
  return temp;
}
inline ::object_detection::protos::BoxPredictor* Ssd::mutable_box_predictor() {
  _has_bits_[0] |= 0x00000020u;
  if (box_predictor_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::BoxPredictor>(GetArenaNoVirtual());
    box_predictor_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.box_predictor)
  return box_predictor_;
}
inline void Ssd::set_allocated_box_predictor(::object_detection::protos::BoxPredictor* box_predictor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(box_predictor_);
  }
  if (box_predictor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      box_predictor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, box_predictor, submessage_arena);
    }
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  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::has_anchor_generator() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline const ::object_detection::protos::AnchorGenerator& Ssd::anchor_generator() const {
  const ::object_detection::protos::AnchorGenerator* p = anchor_generator_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.anchor_generator)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::AnchorGenerator*>(
      &::object_detection::protos::_AnchorGenerator_default_instance_);
}
inline ::object_detection::protos::AnchorGenerator* Ssd::release_anchor_generator() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.anchor_generator)
  _has_bits_[0] &= ~0x00000040u;
  ::object_detection::protos::AnchorGenerator* temp = anchor_generator_;
  anchor_generator_ = nullptr;
  return temp;
}
inline ::object_detection::protos::AnchorGenerator* Ssd::mutable_anchor_generator() {
  _has_bits_[0] |= 0x00000040u;
  if (anchor_generator_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::AnchorGenerator>(GetArenaNoVirtual());
    anchor_generator_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.anchor_generator)
  return anchor_generator_;
}
inline void Ssd::set_allocated_anchor_generator(::object_detection::protos::AnchorGenerator* anchor_generator) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(anchor_generator_);
  }
  if (anchor_generator) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      anchor_generator = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, anchor_generator, submessage_arena);
    }
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  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::has_post_processing() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline const ::object_detection::protos::PostProcessing& Ssd::post_processing() const {
  const ::object_detection::protos::PostProcessing* p = post_processing_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.post_processing)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::PostProcessing*>(
      &::object_detection::protos::_PostProcessing_default_instance_);
}
inline ::object_detection::protos::PostProcessing* Ssd::release_post_processing() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.post_processing)
  _has_bits_[0] &= ~0x00000080u;
  ::object_detection::protos::PostProcessing* temp = post_processing_;
  post_processing_ = nullptr;
  return temp;
}
inline ::object_detection::protos::PostProcessing* Ssd::mutable_post_processing() {
  _has_bits_[0] |= 0x00000080u;
  if (post_processing_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::PostProcessing>(GetArenaNoVirtual());
    post_processing_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.post_processing)
  return post_processing_;
}
inline void Ssd::set_allocated_post_processing(::object_detection::protos::PostProcessing* post_processing) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_processing_);
  }
  if (post_processing) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      post_processing = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, post_processing, submessage_arena);
    }
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  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::has_normalize_loss_by_num_matches() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void Ssd::clear_normalize_loss_by_num_matches() {
  normalize_loss_by_num_matches_ = true;
  _has_bits_[0] &= ~0x00080000u;
}
inline bool Ssd::normalize_loss_by_num_matches() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.normalize_loss_by_num_matches)
  return normalize_loss_by_num_matches_;
}
inline void Ssd::set_normalize_loss_by_num_matches(bool value) {
  _has_bits_[0] |= 0x00080000u;
  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::has_normalize_loc_loss_by_codesize() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Ssd::clear_normalize_loc_loss_by_codesize() {
  normalize_loc_loss_by_codesize_ = false;
  _has_bits_[0] &= ~0x00001000u;
}
inline bool Ssd::normalize_loc_loss_by_codesize() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.normalize_loc_loss_by_codesize)
  return normalize_loc_loss_by_codesize_;
}
inline void Ssd::set_normalize_loc_loss_by_codesize(bool value) {
  _has_bits_[0] |= 0x00001000u;
  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::has_loss() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline const ::object_detection::protos::Loss& Ssd::loss() const {
  const ::object_detection::protos::Loss* p = loss_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.loss)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Loss*>(
      &::object_detection::protos::_Loss_default_instance_);
}
inline ::object_detection::protos::Loss* Ssd::release_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.loss)
  _has_bits_[0] &= ~0x00000100u;
  ::object_detection::protos::Loss* temp = loss_;
  loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Loss* Ssd::mutable_loss() {
  _has_bits_[0] |= 0x00000100u;
  if (loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Loss>(GetArenaNoVirtual());
    loss_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.loss)
  return loss_;
}
inline void Ssd::set_allocated_loss(::object_detection::protos::Loss* loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(loss_);
  }
  if (loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, loss, submessage_arena);
    }
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  loss_ = loss;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Ssd.loss)
}

// optional bool freeze_batchnorm = 16 [default = false];
inline bool Ssd::has_freeze_batchnorm() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Ssd::clear_freeze_batchnorm() {
  freeze_batchnorm_ = false;
  _has_bits_[0] &= ~0x00002000u;
}
inline bool Ssd::freeze_batchnorm() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.freeze_batchnorm)
  return freeze_batchnorm_;
}
inline void Ssd::set_freeze_batchnorm(bool value) {
  _has_bits_[0] |= 0x00002000u;
  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::has_inplace_batchnorm_update() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void Ssd::clear_inplace_batchnorm_update() {
  inplace_batchnorm_update_ = false;
  _has_bits_[0] &= ~0x00004000u;
}
inline bool Ssd::inplace_batchnorm_update() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.inplace_batchnorm_update)
  return inplace_batchnorm_update_;
}
inline void Ssd::set_inplace_batchnorm_update(bool value) {
  _has_bits_[0] |= 0x00004000u;
  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::has_add_background_class() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void Ssd::clear_add_background_class() {
  add_background_class_ = true;
  _has_bits_[0] &= ~0x00100000u;
}
inline bool Ssd::add_background_class() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.add_background_class)
  return add_background_class_;
}
inline void Ssd::set_add_background_class(bool value) {
  _has_bits_[0] |= 0x00100000u;
  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::has_explicit_background_class() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void Ssd::clear_explicit_background_class() {
  explicit_background_class_ = false;
  _has_bits_[0] &= ~0x00008000u;
}
inline bool Ssd::explicit_background_class() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.explicit_background_class)
  return explicit_background_class_;
}
inline void Ssd::set_explicit_background_class(bool value) {
  _has_bits_[0] |= 0x00008000u;
  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::has_use_confidences_as_targets() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void Ssd::clear_use_confidences_as_targets() {
  use_confidences_as_targets_ = false;
  _has_bits_[0] &= ~0x00010000u;
}
inline bool Ssd::use_confidences_as_targets() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.use_confidences_as_targets)
  return use_confidences_as_targets_;
}
inline void Ssd::set_use_confidences_as_targets(bool value) {
  _has_bits_[0] |= 0x00010000u;
  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::has_implicit_example_weight() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void Ssd::clear_implicit_example_weight() {
  implicit_example_weight_ = 1;
  _has_bits_[0] &= ~0x00020000u;
}
inline float Ssd::implicit_example_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.implicit_example_weight)
  return implicit_example_weight_;
}
inline void Ssd::set_implicit_example_weight(float value) {
  _has_bits_[0] |= 0x00020000u;
  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::has_mask_head_config() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Ssd::clear_mask_head_config() {
  if (mask_head_config_ != nullptr) mask_head_config_->Clear();
  _has_bits_[0] &= ~0x00000200u;
}
inline const ::object_detection::protos::Ssd_MaskHead& Ssd::mask_head_config() const {
  const ::object_detection::protos::Ssd_MaskHead* p = mask_head_config_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Ssd.mask_head_config)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Ssd_MaskHead*>(
      &::object_detection::protos::_Ssd_MaskHead_default_instance_);
}
inline ::object_detection::protos::Ssd_MaskHead* Ssd::release_mask_head_config() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Ssd.mask_head_config)
  _has_bits_[0] &= ~0x00000200u;
  ::object_detection::protos::Ssd_MaskHead* temp = mask_head_config_;
  mask_head_config_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Ssd_MaskHead* Ssd::mutable_mask_head_config() {
  _has_bits_[0] |= 0x00000200u;
  if (mask_head_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Ssd_MaskHead>(GetArenaNoVirtual());
    mask_head_config_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Ssd.mask_head_config)
  return mask_head_config_;
}
inline void Ssd::set_allocated_mask_head_config(::object_detection::protos::Ssd_MaskHead* mask_head_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete mask_head_config_;
  }
  if (mask_head_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      mask_head_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mask_head_config, submessage_arena);
    }
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  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::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SsdFeatureExtractor::clear_type() {
  type_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SsdFeatureExtractor::type() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.type)
  return type_.GetNoArena();
}
inline void SsdFeatureExtractor::set_type(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.type)
}
inline void SsdFeatureExtractor::set_type(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  type_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:object_detection.protos.SsdFeatureExtractor.type)
}
inline void SsdFeatureExtractor::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:object_detection.protos.SsdFeatureExtractor.type)
}
inline void SsdFeatureExtractor::set_type(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:object_detection.protos.SsdFeatureExtractor.type)
}
inline std::string* SsdFeatureExtractor::mutable_type() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SsdFeatureExtractor.type)
  return type_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SsdFeatureExtractor::release_type() {
  // @@protoc_insertion_point(field_release:object_detection.protos.SsdFeatureExtractor.type)
  if (!has_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return type_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SsdFeatureExtractor::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  type_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type);
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.SsdFeatureExtractor.type)
}

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

// optional int32 min_depth = 3 [default = 16];
inline bool SsdFeatureExtractor::has_min_depth() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void SsdFeatureExtractor::clear_min_depth() {
  min_depth_ = 16;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SsdFeatureExtractor::min_depth() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.min_depth)
  return min_depth_;
}
inline void SsdFeatureExtractor::set_min_depth(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000100u;
  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::has_conv_hyperparams() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline const ::object_detection::protos::Hyperparams& SsdFeatureExtractor::conv_hyperparams() const {
  const ::object_detection::protos::Hyperparams* p = conv_hyperparams_;
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Hyperparams*>(
      &::object_detection::protos::_Hyperparams_default_instance_);
}
inline ::object_detection::protos::Hyperparams* SsdFeatureExtractor::release_conv_hyperparams() {
  // @@protoc_insertion_point(field_release:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
  _has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::Hyperparams* temp = conv_hyperparams_;
  conv_hyperparams_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Hyperparams* SsdFeatureExtractor::mutable_conv_hyperparams() {
  _has_bits_[0] |= 0x00000002u;
  if (conv_hyperparams_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Hyperparams>(GetArenaNoVirtual());
    conv_hyperparams_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SsdFeatureExtractor.conv_hyperparams)
  return conv_hyperparams_;
}
inline void SsdFeatureExtractor::set_allocated_conv_hyperparams(::object_detection::protos::Hyperparams* conv_hyperparams) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(conv_hyperparams_);
  }
  if (conv_hyperparams) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      conv_hyperparams = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, conv_hyperparams, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  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::has_override_base_feature_extractor_hyperparams() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SsdFeatureExtractor::clear_override_base_feature_extractor_hyperparams() {
  override_base_feature_extractor_hyperparams_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool SsdFeatureExtractor::override_base_feature_extractor_hyperparams() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.override_base_feature_extractor_hyperparams)
  return override_base_feature_extractor_hyperparams_;
}
inline void SsdFeatureExtractor::set_override_base_feature_extractor_hyperparams(bool value) {
  _has_bits_[0] |= 0x00000008u;
  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::has_pad_to_multiple() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void SsdFeatureExtractor::clear_pad_to_multiple() {
  pad_to_multiple_ = 1;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SsdFeatureExtractor::pad_to_multiple() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.pad_to_multiple)
  return pad_to_multiple_;
}
inline void SsdFeatureExtractor::set_pad_to_multiple(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000200u;
  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::has_use_explicit_padding() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SsdFeatureExtractor::clear_use_explicit_padding() {
  use_explicit_padding_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool SsdFeatureExtractor::use_explicit_padding() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.use_explicit_padding)
  return use_explicit_padding_;
}
inline void SsdFeatureExtractor::set_use_explicit_padding(bool value) {
  _has_bits_[0] |= 0x00000010u;
  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::has_use_depthwise() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void SsdFeatureExtractor::clear_use_depthwise() {
  use_depthwise_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool SsdFeatureExtractor::use_depthwise() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.use_depthwise)
  return use_depthwise_;
}
inline void SsdFeatureExtractor::set_use_depthwise(bool value) {
  _has_bits_[0] |= 0x00000020u;
  use_depthwise_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.SsdFeatureExtractor.use_depthwise)
}

// optional .object_detection.protos.FeaturePyramidNetworks fpn = 10;
inline bool SsdFeatureExtractor::has_fpn() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SsdFeatureExtractor::clear_fpn() {
  if (fpn_ != nullptr) fpn_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::object_detection::protos::FeaturePyramidNetworks& SsdFeatureExtractor::fpn() const {
  const ::object_detection::protos::FeaturePyramidNetworks* p = fpn_;
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.fpn)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::FeaturePyramidNetworks*>(
      &::object_detection::protos::_FeaturePyramidNetworks_default_instance_);
}
inline ::object_detection::protos::FeaturePyramidNetworks* SsdFeatureExtractor::release_fpn() {
  // @@protoc_insertion_point(field_release:object_detection.protos.SsdFeatureExtractor.fpn)
  _has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::FeaturePyramidNetworks* temp = fpn_;
  fpn_ = nullptr;
  return temp;
}
inline ::object_detection::protos::FeaturePyramidNetworks* SsdFeatureExtractor::mutable_fpn() {
  _has_bits_[0] |= 0x00000004u;
  if (fpn_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::FeaturePyramidNetworks>(GetArenaNoVirtual());
    fpn_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.SsdFeatureExtractor.fpn)
  return fpn_;
}
inline void SsdFeatureExtractor::set_allocated_fpn(::object_detection::protos::FeaturePyramidNetworks* fpn) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete fpn_;
  }
  if (fpn) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      fpn = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fpn, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  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::has_replace_preprocessor_with_placeholder() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void SsdFeatureExtractor::clear_replace_preprocessor_with_placeholder() {
  replace_preprocessor_with_placeholder_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool SsdFeatureExtractor::replace_preprocessor_with_placeholder() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.replace_preprocessor_with_placeholder)
  return replace_preprocessor_with_placeholder_;
}
inline void SsdFeatureExtractor::set_replace_preprocessor_with_placeholder(bool value) {
  _has_bits_[0] |= 0x00000040u;
  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::has_num_layers() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void SsdFeatureExtractor::clear_num_layers() {
  num_layers_ = 6;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SsdFeatureExtractor::num_layers() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SsdFeatureExtractor.num_layers)
  return num_layers_;
}
inline void SsdFeatureExtractor::set_num_layers(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000400u;
  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::has_min_level() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FeaturePyramidNetworks::clear_min_level() {
  min_level_ = 3;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FeaturePyramidNetworks::min_level() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.FeaturePyramidNetworks.min_level)
  return min_level_;
}
inline void FeaturePyramidNetworks::set_min_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  min_level_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.FeaturePyramidNetworks.min_level)
}

// optional int32 max_level = 2 [default = 7];
inline bool FeaturePyramidNetworks::has_max_level() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FeaturePyramidNetworks::clear_max_level() {
  max_level_ = 7;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FeaturePyramidNetworks::max_level() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.FeaturePyramidNetworks.max_level)
  return max_level_;
}
inline void FeaturePyramidNetworks::set_max_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  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::has_additional_layer_depth() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FeaturePyramidNetworks::clear_additional_layer_depth() {
  additional_layer_depth_ = 256;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FeaturePyramidNetworks::additional_layer_depth() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.FeaturePyramidNetworks.additional_layer_depth)
  return additional_layer_depth_;
}
inline void FeaturePyramidNetworks::set_additional_layer_depth(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000001u;
  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
