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

#ifndef GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2flosses_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2flosses_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_object_5fdetection_2fprotos_2flosses_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_2flosses_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[14]
    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_2flosses_2eproto;
namespace object_detection {
namespace protos {
class BootstrappedSigmoidClassificationLoss;
class BootstrappedSigmoidClassificationLossDefaultTypeInternal;
extern BootstrappedSigmoidClassificationLossDefaultTypeInternal _BootstrappedSigmoidClassificationLoss_default_instance_;
class ClassificationLoss;
class ClassificationLossDefaultTypeInternal;
extern ClassificationLossDefaultTypeInternal _ClassificationLoss_default_instance_;
class HardExampleMiner;
class HardExampleMinerDefaultTypeInternal;
extern HardExampleMinerDefaultTypeInternal _HardExampleMiner_default_instance_;
class LocalizationLoss;
class LocalizationLossDefaultTypeInternal;
extern LocalizationLossDefaultTypeInternal _LocalizationLoss_default_instance_;
class Loss;
class LossDefaultTypeInternal;
extern LossDefaultTypeInternal _Loss_default_instance_;
class Loss_EqualizationLoss;
class Loss_EqualizationLossDefaultTypeInternal;
extern Loss_EqualizationLossDefaultTypeInternal _Loss_EqualizationLoss_default_instance_;
class RandomExampleSampler;
class RandomExampleSamplerDefaultTypeInternal;
extern RandomExampleSamplerDefaultTypeInternal _RandomExampleSampler_default_instance_;
class SigmoidFocalClassificationLoss;
class SigmoidFocalClassificationLossDefaultTypeInternal;
extern SigmoidFocalClassificationLossDefaultTypeInternal _SigmoidFocalClassificationLoss_default_instance_;
class WeightedIOULocalizationLoss;
class WeightedIOULocalizationLossDefaultTypeInternal;
extern WeightedIOULocalizationLossDefaultTypeInternal _WeightedIOULocalizationLoss_default_instance_;
class WeightedL2LocalizationLoss;
class WeightedL2LocalizationLossDefaultTypeInternal;
extern WeightedL2LocalizationLossDefaultTypeInternal _WeightedL2LocalizationLoss_default_instance_;
class WeightedSigmoidClassificationLoss;
class WeightedSigmoidClassificationLossDefaultTypeInternal;
extern WeightedSigmoidClassificationLossDefaultTypeInternal _WeightedSigmoidClassificationLoss_default_instance_;
class WeightedSmoothL1LocalizationLoss;
class WeightedSmoothL1LocalizationLossDefaultTypeInternal;
extern WeightedSmoothL1LocalizationLossDefaultTypeInternal _WeightedSmoothL1LocalizationLoss_default_instance_;
class WeightedSoftmaxClassificationAgainstLogitsLoss;
class WeightedSoftmaxClassificationAgainstLogitsLossDefaultTypeInternal;
extern WeightedSoftmaxClassificationAgainstLogitsLossDefaultTypeInternal _WeightedSoftmaxClassificationAgainstLogitsLoss_default_instance_;
class WeightedSoftmaxClassificationLoss;
class WeightedSoftmaxClassificationLossDefaultTypeInternal;
extern WeightedSoftmaxClassificationLossDefaultTypeInternal _WeightedSoftmaxClassificationLoss_default_instance_;
}  // namespace protos
}  // namespace object_detection
PROTOBUF_NAMESPACE_OPEN
template<> ::object_detection::protos::BootstrappedSigmoidClassificationLoss* Arena::CreateMaybeMessage<::object_detection::protos::BootstrappedSigmoidClassificationLoss>(Arena*);
template<> ::object_detection::protos::ClassificationLoss* Arena::CreateMaybeMessage<::object_detection::protos::ClassificationLoss>(Arena*);
template<> ::object_detection::protos::HardExampleMiner* Arena::CreateMaybeMessage<::object_detection::protos::HardExampleMiner>(Arena*);
template<> ::object_detection::protos::LocalizationLoss* Arena::CreateMaybeMessage<::object_detection::protos::LocalizationLoss>(Arena*);
template<> ::object_detection::protos::Loss* Arena::CreateMaybeMessage<::object_detection::protos::Loss>(Arena*);
template<> ::object_detection::protos::Loss_EqualizationLoss* Arena::CreateMaybeMessage<::object_detection::protos::Loss_EqualizationLoss>(Arena*);
template<> ::object_detection::protos::RandomExampleSampler* Arena::CreateMaybeMessage<::object_detection::protos::RandomExampleSampler>(Arena*);
template<> ::object_detection::protos::SigmoidFocalClassificationLoss* Arena::CreateMaybeMessage<::object_detection::protos::SigmoidFocalClassificationLoss>(Arena*);
template<> ::object_detection::protos::WeightedIOULocalizationLoss* Arena::CreateMaybeMessage<::object_detection::protos::WeightedIOULocalizationLoss>(Arena*);
template<> ::object_detection::protos::WeightedL2LocalizationLoss* Arena::CreateMaybeMessage<::object_detection::protos::WeightedL2LocalizationLoss>(Arena*);
template<> ::object_detection::protos::WeightedSigmoidClassificationLoss* Arena::CreateMaybeMessage<::object_detection::protos::WeightedSigmoidClassificationLoss>(Arena*);
template<> ::object_detection::protos::WeightedSmoothL1LocalizationLoss* Arena::CreateMaybeMessage<::object_detection::protos::WeightedSmoothL1LocalizationLoss>(Arena*);
template<> ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* Arena::CreateMaybeMessage<::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss>(Arena*);
template<> ::object_detection::protos::WeightedSoftmaxClassificationLoss* Arena::CreateMaybeMessage<::object_detection::protos::WeightedSoftmaxClassificationLoss>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace object_detection {
namespace protos {

enum Loss_ExpectedLossWeights : int {
  Loss_ExpectedLossWeights_NONE = 0,
  Loss_ExpectedLossWeights_EXPECTED_SAMPLING = 1,
  Loss_ExpectedLossWeights_REWEIGHTING_UNMATCHED_ANCHORS = 2
};
bool Loss_ExpectedLossWeights_IsValid(int value);
constexpr Loss_ExpectedLossWeights Loss_ExpectedLossWeights_ExpectedLossWeights_MIN = Loss_ExpectedLossWeights_NONE;
constexpr Loss_ExpectedLossWeights Loss_ExpectedLossWeights_ExpectedLossWeights_MAX = Loss_ExpectedLossWeights_REWEIGHTING_UNMATCHED_ANCHORS;
constexpr int Loss_ExpectedLossWeights_ExpectedLossWeights_ARRAYSIZE = Loss_ExpectedLossWeights_ExpectedLossWeights_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Loss_ExpectedLossWeights_descriptor();
template<typename T>
inline const std::string& Loss_ExpectedLossWeights_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Loss_ExpectedLossWeights>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Loss_ExpectedLossWeights_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Loss_ExpectedLossWeights_descriptor(), enum_t_value);
}
inline bool Loss_ExpectedLossWeights_Parse(
    const std::string& name, Loss_ExpectedLossWeights* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Loss_ExpectedLossWeights>(
    Loss_ExpectedLossWeights_descriptor(), name, value);
}
enum HardExampleMiner_LossType : int {
  HardExampleMiner_LossType_BOTH = 0,
  HardExampleMiner_LossType_CLASSIFICATION = 1,
  HardExampleMiner_LossType_LOCALIZATION = 2
};
bool HardExampleMiner_LossType_IsValid(int value);
constexpr HardExampleMiner_LossType HardExampleMiner_LossType_LossType_MIN = HardExampleMiner_LossType_BOTH;
constexpr HardExampleMiner_LossType HardExampleMiner_LossType_LossType_MAX = HardExampleMiner_LossType_LOCALIZATION;
constexpr int HardExampleMiner_LossType_LossType_ARRAYSIZE = HardExampleMiner_LossType_LossType_MAX + 1;

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

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

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

  inline Loss_EqualizationLoss& operator=(const Loss_EqualizationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline Loss_EqualizationLoss& operator=(Loss_EqualizationLoss&& 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 Loss_EqualizationLoss& default_instance();

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

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

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

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

  Loss_EqualizationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Loss_EqualizationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Loss_EqualizationLoss& from);
  void MergeFrom(const Loss_EqualizationLoss& 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(Loss_EqualizationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Loss.EqualizationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kExcludePrefixesFieldNumber = 2,
    kWeightFieldNumber = 1,
  };
  // repeated string exclude_prefixes = 2;
  int exclude_prefixes_size() const;
  void clear_exclude_prefixes();
  const std::string& exclude_prefixes(int index) const;
  std::string* mutable_exclude_prefixes(int index);
  void set_exclude_prefixes(int index, const std::string& value);
  void set_exclude_prefixes(int index, std::string&& value);
  void set_exclude_prefixes(int index, const char* value);
  void set_exclude_prefixes(int index, const char* value, size_t size);
  std::string* add_exclude_prefixes();
  void add_exclude_prefixes(const std::string& value);
  void add_exclude_prefixes(std::string&& value);
  void add_exclude_prefixes(const char* value);
  void add_exclude_prefixes(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& exclude_prefixes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_exclude_prefixes();

  // optional float weight = 1 [default = 0];
  bool has_weight() const;
  void clear_weight();
  float weight() const;
  void set_weight(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.Loss.EqualizationLoss)
 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::RepeatedPtrField<std::string> exclude_prefixes_;
  float weight_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Loss& operator=(const Loss& from) {
    CopyFrom(from);
    return *this;
  }
  inline Loss& operator=(Loss&& 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 Loss& default_instance();

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

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

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

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

  Loss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Loss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Loss& from);
  void MergeFrom(const Loss& 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(Loss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.Loss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef Loss_EqualizationLoss EqualizationLoss;

  typedef Loss_ExpectedLossWeights ExpectedLossWeights;
  static constexpr ExpectedLossWeights NONE =
    Loss_ExpectedLossWeights_NONE;
  static constexpr ExpectedLossWeights EXPECTED_SAMPLING =
    Loss_ExpectedLossWeights_EXPECTED_SAMPLING;
  static constexpr ExpectedLossWeights REWEIGHTING_UNMATCHED_ANCHORS =
    Loss_ExpectedLossWeights_REWEIGHTING_UNMATCHED_ANCHORS;
  static inline bool ExpectedLossWeights_IsValid(int value) {
    return Loss_ExpectedLossWeights_IsValid(value);
  }
  static constexpr ExpectedLossWeights ExpectedLossWeights_MIN =
    Loss_ExpectedLossWeights_ExpectedLossWeights_MIN;
  static constexpr ExpectedLossWeights ExpectedLossWeights_MAX =
    Loss_ExpectedLossWeights_ExpectedLossWeights_MAX;
  static constexpr int ExpectedLossWeights_ARRAYSIZE =
    Loss_ExpectedLossWeights_ExpectedLossWeights_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ExpectedLossWeights_descriptor() {
    return Loss_ExpectedLossWeights_descriptor();
  }
  template<typename T>
  static inline const std::string& ExpectedLossWeights_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ExpectedLossWeights>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ExpectedLossWeights_Name.");
    return Loss_ExpectedLossWeights_Name(enum_t_value);
  }
  static inline bool ExpectedLossWeights_Parse(const std::string& name,
      ExpectedLossWeights* value) {
    return Loss_ExpectedLossWeights_Parse(name, value);
  }

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

  enum : int {
    kLocalizationLossFieldNumber = 1,
    kClassificationLossFieldNumber = 2,
    kHardExampleMinerFieldNumber = 3,
    kRandomExampleSamplerFieldNumber = 6,
    kEqualizationLossFieldNumber = 7,
    kExpectedLossWeightsFieldNumber = 18,
    kMinNumNegativeSamplesFieldNumber = 19,
    kDesiredNegativeSamplingRatioFieldNumber = 20,
    kClassificationWeightFieldNumber = 4,
    kLocalizationWeightFieldNumber = 5,
  };
  // optional .object_detection.protos.LocalizationLoss localization_loss = 1;
  bool has_localization_loss() const;
  void clear_localization_loss();
  const ::object_detection::protos::LocalizationLoss& localization_loss() const;
  ::object_detection::protos::LocalizationLoss* release_localization_loss();
  ::object_detection::protos::LocalizationLoss* mutable_localization_loss();
  void set_allocated_localization_loss(::object_detection::protos::LocalizationLoss* localization_loss);

  // optional .object_detection.protos.ClassificationLoss classification_loss = 2;
  bool has_classification_loss() const;
  void clear_classification_loss();
  const ::object_detection::protos::ClassificationLoss& classification_loss() const;
  ::object_detection::protos::ClassificationLoss* release_classification_loss();
  ::object_detection::protos::ClassificationLoss* mutable_classification_loss();
  void set_allocated_classification_loss(::object_detection::protos::ClassificationLoss* classification_loss);

  // optional .object_detection.protos.HardExampleMiner hard_example_miner = 3;
  bool has_hard_example_miner() const;
  void clear_hard_example_miner();
  const ::object_detection::protos::HardExampleMiner& hard_example_miner() const;
  ::object_detection::protos::HardExampleMiner* release_hard_example_miner();
  ::object_detection::protos::HardExampleMiner* mutable_hard_example_miner();
  void set_allocated_hard_example_miner(::object_detection::protos::HardExampleMiner* hard_example_miner);

  // optional .object_detection.protos.RandomExampleSampler random_example_sampler = 6;
  bool has_random_example_sampler() const;
  void clear_random_example_sampler();
  const ::object_detection::protos::RandomExampleSampler& random_example_sampler() const;
  ::object_detection::protos::RandomExampleSampler* release_random_example_sampler();
  ::object_detection::protos::RandomExampleSampler* mutable_random_example_sampler();
  void set_allocated_random_example_sampler(::object_detection::protos::RandomExampleSampler* random_example_sampler);

  // optional .object_detection.protos.Loss.EqualizationLoss equalization_loss = 7;
  bool has_equalization_loss() const;
  void clear_equalization_loss();
  const ::object_detection::protos::Loss_EqualizationLoss& equalization_loss() const;
  ::object_detection::protos::Loss_EqualizationLoss* release_equalization_loss();
  ::object_detection::protos::Loss_EqualizationLoss* mutable_equalization_loss();
  void set_allocated_equalization_loss(::object_detection::protos::Loss_EqualizationLoss* equalization_loss);

  // optional .object_detection.protos.Loss.ExpectedLossWeights expected_loss_weights = 18 [default = NONE];
  bool has_expected_loss_weights() const;
  void clear_expected_loss_weights();
  ::object_detection::protos::Loss_ExpectedLossWeights expected_loss_weights() const;
  void set_expected_loss_weights(::object_detection::protos::Loss_ExpectedLossWeights value);

  // optional float min_num_negative_samples = 19 [default = 0];
  bool has_min_num_negative_samples() const;
  void clear_min_num_negative_samples();
  float min_num_negative_samples() const;
  void set_min_num_negative_samples(float value);

  // optional float desired_negative_sampling_ratio = 20 [default = 3];
  bool has_desired_negative_sampling_ratio() const;
  void clear_desired_negative_sampling_ratio();
  float desired_negative_sampling_ratio() const;
  void set_desired_negative_sampling_ratio(float value);

  // optional float classification_weight = 4 [default = 1];
  bool has_classification_weight() const;
  void clear_classification_weight();
  float classification_weight() const;
  void set_classification_weight(float value);

  // optional float localization_weight = 5 [default = 1];
  bool has_localization_weight() const;
  void clear_localization_weight();
  float localization_weight() const;
  void set_localization_weight(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.Loss)
 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::LocalizationLoss* localization_loss_;
  ::object_detection::protos::ClassificationLoss* classification_loss_;
  ::object_detection::protos::HardExampleMiner* hard_example_miner_;
  ::object_detection::protos::RandomExampleSampler* random_example_sampler_;
  ::object_detection::protos::Loss_EqualizationLoss* equalization_loss_;
  int expected_loss_weights_;
  float min_num_negative_samples_;
  float desired_negative_sampling_ratio_;
  float classification_weight_;
  float localization_weight_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LocalizationLoss& operator=(const LocalizationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline LocalizationLoss& operator=(LocalizationLoss&& 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 LocalizationLoss& default_instance();

  enum LocalizationLossCase {
    kWeightedL2 = 1,
    kWeightedSmoothL1 = 2,
    kWeightedIou = 3,
    LOCALIZATION_LOSS_NOT_SET = 0,
  };

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

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

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

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

  LocalizationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LocalizationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LocalizationLoss& from);
  void MergeFrom(const LocalizationLoss& 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(LocalizationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.LocalizationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWeightedL2FieldNumber = 1,
    kWeightedSmoothL1FieldNumber = 2,
    kWeightedIouFieldNumber = 3,
  };
  // optional .object_detection.protos.WeightedL2LocalizationLoss weighted_l2 = 1;
  bool has_weighted_l2() const;
  void clear_weighted_l2();
  const ::object_detection::protos::WeightedL2LocalizationLoss& weighted_l2() const;
  ::object_detection::protos::WeightedL2LocalizationLoss* release_weighted_l2();
  ::object_detection::protos::WeightedL2LocalizationLoss* mutable_weighted_l2();
  void set_allocated_weighted_l2(::object_detection::protos::WeightedL2LocalizationLoss* weighted_l2);

  // optional .object_detection.protos.WeightedSmoothL1LocalizationLoss weighted_smooth_l1 = 2;
  bool has_weighted_smooth_l1() const;
  void clear_weighted_smooth_l1();
  const ::object_detection::protos::WeightedSmoothL1LocalizationLoss& weighted_smooth_l1() const;
  ::object_detection::protos::WeightedSmoothL1LocalizationLoss* release_weighted_smooth_l1();
  ::object_detection::protos::WeightedSmoothL1LocalizationLoss* mutable_weighted_smooth_l1();
  void set_allocated_weighted_smooth_l1(::object_detection::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1);

  // optional .object_detection.protos.WeightedIOULocalizationLoss weighted_iou = 3;
  bool has_weighted_iou() const;
  void clear_weighted_iou();
  const ::object_detection::protos::WeightedIOULocalizationLoss& weighted_iou() const;
  ::object_detection::protos::WeightedIOULocalizationLoss* release_weighted_iou();
  ::object_detection::protos::WeightedIOULocalizationLoss* mutable_weighted_iou();
  void set_allocated_weighted_iou(::object_detection::protos::WeightedIOULocalizationLoss* weighted_iou);

  void clear_localization_loss();
  LocalizationLossCase localization_loss_case() const;
  // @@protoc_insertion_point(class_scope:object_detection.protos.LocalizationLoss)
 private:
  class _Internal;
  void set_has_weighted_l2();
  void set_has_weighted_smooth_l1();
  void set_has_weighted_iou();

  inline bool has_localization_loss() const;
  inline void clear_has_localization_loss();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  union LocalizationLossUnion {
    LocalizationLossUnion() {}
    ::object_detection::protos::WeightedL2LocalizationLoss* weighted_l2_;
    ::object_detection::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1_;
    ::object_detection::protos::WeightedIOULocalizationLoss* weighted_iou_;
  } localization_loss_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WeightedL2LocalizationLoss& operator=(const WeightedL2LocalizationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline WeightedL2LocalizationLoss& operator=(WeightedL2LocalizationLoss&& 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 WeightedL2LocalizationLoss& default_instance();

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

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

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

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

  WeightedL2LocalizationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WeightedL2LocalizationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WeightedL2LocalizationLoss& from);
  void MergeFrom(const WeightedL2LocalizationLoss& 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(WeightedL2LocalizationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.WeightedL2LocalizationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAnchorwiseOutputFieldNumber = 1,
  };
  // optional bool anchorwise_output = 1 [default = false];
  bool has_anchorwise_output() const;
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool anchorwise_output_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WeightedSmoothL1LocalizationLoss& operator=(const WeightedSmoothL1LocalizationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline WeightedSmoothL1LocalizationLoss& operator=(WeightedSmoothL1LocalizationLoss&& 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 WeightedSmoothL1LocalizationLoss& default_instance();

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

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

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

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

  WeightedSmoothL1LocalizationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WeightedSmoothL1LocalizationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WeightedSmoothL1LocalizationLoss& from);
  void MergeFrom(const WeightedSmoothL1LocalizationLoss& 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(WeightedSmoothL1LocalizationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.WeightedSmoothL1LocalizationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAnchorwiseOutputFieldNumber = 1,
    kDeltaFieldNumber = 2,
  };
  // optional bool anchorwise_output = 1 [default = false];
  bool has_anchorwise_output() const;
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);

  // optional float delta = 2 [default = 1];
  bool has_delta() const;
  void clear_delta();
  float delta() const;
  void set_delta(float value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool anchorwise_output_;
  float delta_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WeightedIOULocalizationLoss& operator=(const WeightedIOULocalizationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline WeightedIOULocalizationLoss& operator=(WeightedIOULocalizationLoss&& 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 WeightedIOULocalizationLoss& default_instance();

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

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

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

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

  WeightedIOULocalizationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WeightedIOULocalizationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WeightedIOULocalizationLoss& from);
  void MergeFrom(const WeightedIOULocalizationLoss& 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(WeightedIOULocalizationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.WeightedIOULocalizationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

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

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

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

  inline ClassificationLoss& operator=(const ClassificationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClassificationLoss& operator=(ClassificationLoss&& 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 ClassificationLoss& default_instance();

  enum ClassificationLossCase {
    kWeightedSigmoid = 1,
    kWeightedSoftmax = 2,
    kWeightedLogitsSoftmax = 5,
    kBootstrappedSigmoid = 3,
    kWeightedSigmoidFocal = 4,
    CLASSIFICATION_LOSS_NOT_SET = 0,
  };

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

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

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

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

  ClassificationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClassificationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ClassificationLoss& from);
  void MergeFrom(const ClassificationLoss& 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(ClassificationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.ClassificationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kWeightedSigmoidFieldNumber = 1,
    kWeightedSoftmaxFieldNumber = 2,
    kWeightedLogitsSoftmaxFieldNumber = 5,
    kBootstrappedSigmoidFieldNumber = 3,
    kWeightedSigmoidFocalFieldNumber = 4,
  };
  // optional .object_detection.protos.WeightedSigmoidClassificationLoss weighted_sigmoid = 1;
  bool has_weighted_sigmoid() const;
  void clear_weighted_sigmoid();
  const ::object_detection::protos::WeightedSigmoidClassificationLoss& weighted_sigmoid() const;
  ::object_detection::protos::WeightedSigmoidClassificationLoss* release_weighted_sigmoid();
  ::object_detection::protos::WeightedSigmoidClassificationLoss* mutable_weighted_sigmoid();
  void set_allocated_weighted_sigmoid(::object_detection::protos::WeightedSigmoidClassificationLoss* weighted_sigmoid);

  // optional .object_detection.protos.WeightedSoftmaxClassificationLoss weighted_softmax = 2;
  bool has_weighted_softmax() const;
  void clear_weighted_softmax();
  const ::object_detection::protos::WeightedSoftmaxClassificationLoss& weighted_softmax() const;
  ::object_detection::protos::WeightedSoftmaxClassificationLoss* release_weighted_softmax();
  ::object_detection::protos::WeightedSoftmaxClassificationLoss* mutable_weighted_softmax();
  void set_allocated_weighted_softmax(::object_detection::protos::WeightedSoftmaxClassificationLoss* weighted_softmax);

  // optional .object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss weighted_logits_softmax = 5;
  bool has_weighted_logits_softmax() const;
  void clear_weighted_logits_softmax();
  const ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss& weighted_logits_softmax() const;
  ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* release_weighted_logits_softmax();
  ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* mutable_weighted_logits_softmax();
  void set_allocated_weighted_logits_softmax(::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* weighted_logits_softmax);

  // optional .object_detection.protos.BootstrappedSigmoidClassificationLoss bootstrapped_sigmoid = 3;
  bool has_bootstrapped_sigmoid() const;
  void clear_bootstrapped_sigmoid();
  const ::object_detection::protos::BootstrappedSigmoidClassificationLoss& bootstrapped_sigmoid() const;
  ::object_detection::protos::BootstrappedSigmoidClassificationLoss* release_bootstrapped_sigmoid();
  ::object_detection::protos::BootstrappedSigmoidClassificationLoss* mutable_bootstrapped_sigmoid();
  void set_allocated_bootstrapped_sigmoid(::object_detection::protos::BootstrappedSigmoidClassificationLoss* bootstrapped_sigmoid);

  // optional .object_detection.protos.SigmoidFocalClassificationLoss weighted_sigmoid_focal = 4;
  bool has_weighted_sigmoid_focal() const;
  void clear_weighted_sigmoid_focal();
  const ::object_detection::protos::SigmoidFocalClassificationLoss& weighted_sigmoid_focal() const;
  ::object_detection::protos::SigmoidFocalClassificationLoss* release_weighted_sigmoid_focal();
  ::object_detection::protos::SigmoidFocalClassificationLoss* mutable_weighted_sigmoid_focal();
  void set_allocated_weighted_sigmoid_focal(::object_detection::protos::SigmoidFocalClassificationLoss* weighted_sigmoid_focal);

  void clear_classification_loss();
  ClassificationLossCase classification_loss_case() const;
  // @@protoc_insertion_point(class_scope:object_detection.protos.ClassificationLoss)
 private:
  class _Internal;
  void set_has_weighted_sigmoid();
  void set_has_weighted_softmax();
  void set_has_weighted_logits_softmax();
  void set_has_bootstrapped_sigmoid();
  void set_has_weighted_sigmoid_focal();

  inline bool has_classification_loss() const;
  inline void clear_has_classification_loss();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  union ClassificationLossUnion {
    ClassificationLossUnion() {}
    ::object_detection::protos::WeightedSigmoidClassificationLoss* weighted_sigmoid_;
    ::object_detection::protos::WeightedSoftmaxClassificationLoss* weighted_softmax_;
    ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* weighted_logits_softmax_;
    ::object_detection::protos::BootstrappedSigmoidClassificationLoss* bootstrapped_sigmoid_;
    ::object_detection::protos::SigmoidFocalClassificationLoss* weighted_sigmoid_focal_;
  } classification_loss_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WeightedSigmoidClassificationLoss& operator=(const WeightedSigmoidClassificationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline WeightedSigmoidClassificationLoss& operator=(WeightedSigmoidClassificationLoss&& 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 WeightedSigmoidClassificationLoss& default_instance();

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

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

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

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

  WeightedSigmoidClassificationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WeightedSigmoidClassificationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WeightedSigmoidClassificationLoss& from);
  void MergeFrom(const WeightedSigmoidClassificationLoss& 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(WeightedSigmoidClassificationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.WeightedSigmoidClassificationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAnchorwiseOutputFieldNumber = 1,
  };
  // optional bool anchorwise_output = 1 [default = false];
  bool has_anchorwise_output() const;
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool anchorwise_output_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline SigmoidFocalClassificationLoss& operator=(const SigmoidFocalClassificationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline SigmoidFocalClassificationLoss& operator=(SigmoidFocalClassificationLoss&& 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 SigmoidFocalClassificationLoss& default_instance();

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

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

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

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

  SigmoidFocalClassificationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SigmoidFocalClassificationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SigmoidFocalClassificationLoss& from);
  void MergeFrom(const SigmoidFocalClassificationLoss& 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(SigmoidFocalClassificationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.SigmoidFocalClassificationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAnchorwiseOutputFieldNumber = 1,
    kAlphaFieldNumber = 3,
    kGammaFieldNumber = 2,
  };
  // optional bool anchorwise_output = 1 [default = false];
  bool has_anchorwise_output() const;
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);

  // optional float alpha = 3;
  bool has_alpha() const;
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);

  // optional float gamma = 2 [default = 2];
  bool has_gamma() const;
  void clear_gamma();
  float gamma() const;
  void set_gamma(float value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool anchorwise_output_;
  float alpha_;
  float gamma_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WeightedSoftmaxClassificationLoss& operator=(const WeightedSoftmaxClassificationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline WeightedSoftmaxClassificationLoss& operator=(WeightedSoftmaxClassificationLoss&& 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 WeightedSoftmaxClassificationLoss& default_instance();

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

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

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

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

  WeightedSoftmaxClassificationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WeightedSoftmaxClassificationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WeightedSoftmaxClassificationLoss& from);
  void MergeFrom(const WeightedSoftmaxClassificationLoss& 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(WeightedSoftmaxClassificationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.WeightedSoftmaxClassificationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAnchorwiseOutputFieldNumber = 1,
    kLogitScaleFieldNumber = 2,
  };
  // optional bool anchorwise_output = 1 [default = false];
  bool has_anchorwise_output() const;
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);

  // optional float logit_scale = 2 [default = 1];
  bool has_logit_scale() const;
  void clear_logit_scale();
  float logit_scale() const;
  void set_logit_scale(float value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool anchorwise_output_;
  float logit_scale_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WeightedSoftmaxClassificationAgainstLogitsLoss& operator=(const WeightedSoftmaxClassificationAgainstLogitsLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline WeightedSoftmaxClassificationAgainstLogitsLoss& operator=(WeightedSoftmaxClassificationAgainstLogitsLoss&& 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 WeightedSoftmaxClassificationAgainstLogitsLoss& default_instance();

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

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

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

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

  WeightedSoftmaxClassificationAgainstLogitsLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WeightedSoftmaxClassificationAgainstLogitsLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WeightedSoftmaxClassificationAgainstLogitsLoss& from);
  void MergeFrom(const WeightedSoftmaxClassificationAgainstLogitsLoss& 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(WeightedSoftmaxClassificationAgainstLogitsLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAnchorwiseOutputFieldNumber = 1,
    kLogitScaleFieldNumber = 2,
  };
  // optional bool anchorwise_output = 1 [default = false];
  bool has_anchorwise_output() const;
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);

  // optional float logit_scale = 2 [default = 1];
  bool has_logit_scale() const;
  void clear_logit_scale();
  float logit_scale() const;
  void set_logit_scale(float value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool anchorwise_output_;
  float logit_scale_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BootstrappedSigmoidClassificationLoss& operator=(const BootstrappedSigmoidClassificationLoss& from) {
    CopyFrom(from);
    return *this;
  }
  inline BootstrappedSigmoidClassificationLoss& operator=(BootstrappedSigmoidClassificationLoss&& 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 BootstrappedSigmoidClassificationLoss& default_instance();

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

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

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

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

  BootstrappedSigmoidClassificationLoss* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BootstrappedSigmoidClassificationLoss>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BootstrappedSigmoidClassificationLoss& from);
  void MergeFrom(const BootstrappedSigmoidClassificationLoss& 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(BootstrappedSigmoidClassificationLoss* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.BootstrappedSigmoidClassificationLoss";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAlphaFieldNumber = 1,
    kHardBootstrapFieldNumber = 2,
    kAnchorwiseOutputFieldNumber = 3,
  };
  // optional float alpha = 1;
  bool has_alpha() const;
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);

  // optional bool hard_bootstrap = 2 [default = false];
  bool has_hard_bootstrap() const;
  void clear_hard_bootstrap();
  bool hard_bootstrap() const;
  void set_hard_bootstrap(bool value);

  // optional bool anchorwise_output = 3 [default = false];
  bool has_anchorwise_output() const;
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float alpha_;
  bool hard_bootstrap_;
  bool anchorwise_output_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HardExampleMiner& operator=(const HardExampleMiner& from) {
    CopyFrom(from);
    return *this;
  }
  inline HardExampleMiner& operator=(HardExampleMiner&& 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 HardExampleMiner& default_instance();

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

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

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

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

  HardExampleMiner* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<HardExampleMiner>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const HardExampleMiner& from);
  void MergeFrom(const HardExampleMiner& 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(HardExampleMiner* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.HardExampleMiner";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef HardExampleMiner_LossType LossType;
  static constexpr LossType BOTH =
    HardExampleMiner_LossType_BOTH;
  static constexpr LossType CLASSIFICATION =
    HardExampleMiner_LossType_CLASSIFICATION;
  static constexpr LossType LOCALIZATION =
    HardExampleMiner_LossType_LOCALIZATION;
  static inline bool LossType_IsValid(int value) {
    return HardExampleMiner_LossType_IsValid(value);
  }
  static constexpr LossType LossType_MIN =
    HardExampleMiner_LossType_LossType_MIN;
  static constexpr LossType LossType_MAX =
    HardExampleMiner_LossType_LossType_MAX;
  static constexpr int LossType_ARRAYSIZE =
    HardExampleMiner_LossType_LossType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LossType_descriptor() {
    return HardExampleMiner_LossType_descriptor();
  }
  template<typename T>
  static inline const std::string& LossType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LossType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LossType_Name.");
    return HardExampleMiner_LossType_Name(enum_t_value);
  }
  static inline bool LossType_Parse(const std::string& name,
      LossType* value) {
    return HardExampleMiner_LossType_Parse(name, value);
  }

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

  enum : int {
    kLossTypeFieldNumber = 3,
    kMaxNegativesPerPositiveFieldNumber = 4,
    kMinNegativesPerImageFieldNumber = 5,
    kNumHardExamplesFieldNumber = 1,
    kIouThresholdFieldNumber = 2,
  };
  // optional .object_detection.protos.HardExampleMiner.LossType loss_type = 3 [default = BOTH];
  bool has_loss_type() const;
  void clear_loss_type();
  ::object_detection::protos::HardExampleMiner_LossType loss_type() const;
  void set_loss_type(::object_detection::protos::HardExampleMiner_LossType value);

  // optional int32 max_negatives_per_positive = 4 [default = 0];
  bool has_max_negatives_per_positive() const;
  void clear_max_negatives_per_positive();
  ::PROTOBUF_NAMESPACE_ID::int32 max_negatives_per_positive() const;
  void set_max_negatives_per_positive(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 min_negatives_per_image = 5 [default = 0];
  bool has_min_negatives_per_image() const;
  void clear_min_negatives_per_image();
  ::PROTOBUF_NAMESPACE_ID::int32 min_negatives_per_image() const;
  void set_min_negatives_per_image(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 num_hard_examples = 1 [default = 64];
  bool has_num_hard_examples() const;
  void clear_num_hard_examples();
  ::PROTOBUF_NAMESPACE_ID::int32 num_hard_examples() const;
  void set_num_hard_examples(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional float iou_threshold = 2 [default = 0.7];
  bool has_iou_threshold() const;
  void clear_iou_threshold();
  float iou_threshold() const;
  void set_iou_threshold(float value);

  // @@protoc_insertion_point(class_scope:object_detection.protos.HardExampleMiner)
 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_;
  int loss_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_negatives_per_positive_;
  ::PROTOBUF_NAMESPACE_ID::int32 min_negatives_per_image_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_hard_examples_;
  float iou_threshold_;
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline RandomExampleSampler& operator=(const RandomExampleSampler& from) {
    CopyFrom(from);
    return *this;
  }
  inline RandomExampleSampler& operator=(RandomExampleSampler&& 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 RandomExampleSampler& default_instance();

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

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

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

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

  RandomExampleSampler* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RandomExampleSampler>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RandomExampleSampler& from);
  void MergeFrom(const RandomExampleSampler& 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(RandomExampleSampler* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.RandomExampleSampler";
  }
  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_2flosses_2eproto);
    return ::descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPositiveSampleFractionFieldNumber = 1,
  };
  // optional float positive_sample_fraction = 1 [default = 0.01];
  bool has_positive_sample_fraction() const;
  void clear_positive_sample_fraction();
  float positive_sample_fraction() const;
  void set_positive_sample_fraction(float value);

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

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


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

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

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

// repeated string exclude_prefixes = 2;
inline int Loss_EqualizationLoss::exclude_prefixes_size() const {
  return exclude_prefixes_.size();
}
inline void Loss_EqualizationLoss::clear_exclude_prefixes() {
  exclude_prefixes_.Clear();
}
inline const std::string& Loss_EqualizationLoss::exclude_prefixes(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return exclude_prefixes_.Get(index);
}
inline std::string* Loss_EqualizationLoss::mutable_exclude_prefixes(int index) {
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return exclude_prefixes_.Mutable(index);
}
inline void Loss_EqualizationLoss::set_exclude_prefixes(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  exclude_prefixes_.Mutable(index)->assign(value);
}
inline void Loss_EqualizationLoss::set_exclude_prefixes(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  exclude_prefixes_.Mutable(index)->assign(std::move(value));
}
inline void Loss_EqualizationLoss::set_exclude_prefixes(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  exclude_prefixes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline void Loss_EqualizationLoss::set_exclude_prefixes(int index, const char* value, size_t size) {
  exclude_prefixes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline std::string* Loss_EqualizationLoss::add_exclude_prefixes() {
  // @@protoc_insertion_point(field_add_mutable:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return exclude_prefixes_.Add();
}
inline void Loss_EqualizationLoss::add_exclude_prefixes(const std::string& value) {
  exclude_prefixes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline void Loss_EqualizationLoss::add_exclude_prefixes(std::string&& value) {
  exclude_prefixes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline void Loss_EqualizationLoss::add_exclude_prefixes(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  exclude_prefixes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline void Loss_EqualizationLoss::add_exclude_prefixes(const char* value, size_t size) {
  exclude_prefixes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Loss_EqualizationLoss::exclude_prefixes() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return exclude_prefixes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Loss_EqualizationLoss::mutable_exclude_prefixes() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return &exclude_prefixes_;
}

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

// Loss

// optional .object_detection.protos.LocalizationLoss localization_loss = 1;
inline bool Loss::has_localization_loss() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Loss::clear_localization_loss() {
  if (localization_loss_ != nullptr) localization_loss_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::object_detection::protos::LocalizationLoss& Loss::localization_loss() const {
  const ::object_detection::protos::LocalizationLoss* p = localization_loss_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.localization_loss)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::LocalizationLoss*>(
      &::object_detection::protos::_LocalizationLoss_default_instance_);
}
inline ::object_detection::protos::LocalizationLoss* Loss::release_localization_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.localization_loss)
  _has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::LocalizationLoss* temp = localization_loss_;
  localization_loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::LocalizationLoss* Loss::mutable_localization_loss() {
  _has_bits_[0] |= 0x00000001u;
  if (localization_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::LocalizationLoss>(GetArenaNoVirtual());
    localization_loss_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.localization_loss)
  return localization_loss_;
}
inline void Loss::set_allocated_localization_loss(::object_detection::protos::LocalizationLoss* localization_loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete localization_loss_;
  }
  if (localization_loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      localization_loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, localization_loss, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  localization_loss_ = localization_loss;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Loss.localization_loss)
}

// optional .object_detection.protos.ClassificationLoss classification_loss = 2;
inline bool Loss::has_classification_loss() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Loss::clear_classification_loss() {
  if (classification_loss_ != nullptr) classification_loss_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::object_detection::protos::ClassificationLoss& Loss::classification_loss() const {
  const ::object_detection::protos::ClassificationLoss* p = classification_loss_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.classification_loss)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::ClassificationLoss*>(
      &::object_detection::protos::_ClassificationLoss_default_instance_);
}
inline ::object_detection::protos::ClassificationLoss* Loss::release_classification_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.classification_loss)
  _has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::ClassificationLoss* temp = classification_loss_;
  classification_loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::ClassificationLoss* Loss::mutable_classification_loss() {
  _has_bits_[0] |= 0x00000002u;
  if (classification_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::ClassificationLoss>(GetArenaNoVirtual());
    classification_loss_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.classification_loss)
  return classification_loss_;
}
inline void Loss::set_allocated_classification_loss(::object_detection::protos::ClassificationLoss* classification_loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete classification_loss_;
  }
  if (classification_loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      classification_loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, classification_loss, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  classification_loss_ = classification_loss;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Loss.classification_loss)
}

// optional .object_detection.protos.HardExampleMiner hard_example_miner = 3;
inline bool Loss::has_hard_example_miner() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Loss::clear_hard_example_miner() {
  if (hard_example_miner_ != nullptr) hard_example_miner_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::object_detection::protos::HardExampleMiner& Loss::hard_example_miner() const {
  const ::object_detection::protos::HardExampleMiner* p = hard_example_miner_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.hard_example_miner)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::HardExampleMiner*>(
      &::object_detection::protos::_HardExampleMiner_default_instance_);
}
inline ::object_detection::protos::HardExampleMiner* Loss::release_hard_example_miner() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.hard_example_miner)
  _has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::HardExampleMiner* temp = hard_example_miner_;
  hard_example_miner_ = nullptr;
  return temp;
}
inline ::object_detection::protos::HardExampleMiner* Loss::mutable_hard_example_miner() {
  _has_bits_[0] |= 0x00000004u;
  if (hard_example_miner_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::HardExampleMiner>(GetArenaNoVirtual());
    hard_example_miner_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.hard_example_miner)
  return hard_example_miner_;
}
inline void Loss::set_allocated_hard_example_miner(::object_detection::protos::HardExampleMiner* hard_example_miner) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete hard_example_miner_;
  }
  if (hard_example_miner) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      hard_example_miner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hard_example_miner, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  hard_example_miner_ = hard_example_miner;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Loss.hard_example_miner)
}

// optional float classification_weight = 4 [default = 1];
inline bool Loss::has_classification_weight() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Loss::clear_classification_weight() {
  classification_weight_ = 1;
  _has_bits_[0] &= ~0x00000100u;
}
inline float Loss::classification_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.classification_weight)
  return classification_weight_;
}
inline void Loss::set_classification_weight(float value) {
  _has_bits_[0] |= 0x00000100u;
  classification_weight_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.classification_weight)
}

// optional float localization_weight = 5 [default = 1];
inline bool Loss::has_localization_weight() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Loss::clear_localization_weight() {
  localization_weight_ = 1;
  _has_bits_[0] &= ~0x00000200u;
}
inline float Loss::localization_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.localization_weight)
  return localization_weight_;
}
inline void Loss::set_localization_weight(float value) {
  _has_bits_[0] |= 0x00000200u;
  localization_weight_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.localization_weight)
}

// optional .object_detection.protos.RandomExampleSampler random_example_sampler = 6;
inline bool Loss::has_random_example_sampler() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Loss::clear_random_example_sampler() {
  if (random_example_sampler_ != nullptr) random_example_sampler_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::object_detection::protos::RandomExampleSampler& Loss::random_example_sampler() const {
  const ::object_detection::protos::RandomExampleSampler* p = random_example_sampler_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.random_example_sampler)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::RandomExampleSampler*>(
      &::object_detection::protos::_RandomExampleSampler_default_instance_);
}
inline ::object_detection::protos::RandomExampleSampler* Loss::release_random_example_sampler() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.random_example_sampler)
  _has_bits_[0] &= ~0x00000008u;
  ::object_detection::protos::RandomExampleSampler* temp = random_example_sampler_;
  random_example_sampler_ = nullptr;
  return temp;
}
inline ::object_detection::protos::RandomExampleSampler* Loss::mutable_random_example_sampler() {
  _has_bits_[0] |= 0x00000008u;
  if (random_example_sampler_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::RandomExampleSampler>(GetArenaNoVirtual());
    random_example_sampler_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.random_example_sampler)
  return random_example_sampler_;
}
inline void Loss::set_allocated_random_example_sampler(::object_detection::protos::RandomExampleSampler* random_example_sampler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete random_example_sampler_;
  }
  if (random_example_sampler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      random_example_sampler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, random_example_sampler, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  random_example_sampler_ = random_example_sampler;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Loss.random_example_sampler)
}

// optional .object_detection.protos.Loss.EqualizationLoss equalization_loss = 7;
inline bool Loss::has_equalization_loss() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Loss::clear_equalization_loss() {
  if (equalization_loss_ != nullptr) equalization_loss_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::object_detection::protos::Loss_EqualizationLoss& Loss::equalization_loss() const {
  const ::object_detection::protos::Loss_EqualizationLoss* p = equalization_loss_;
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.equalization_loss)
  return p != nullptr ? *p : *reinterpret_cast<const ::object_detection::protos::Loss_EqualizationLoss*>(
      &::object_detection::protos::_Loss_EqualizationLoss_default_instance_);
}
inline ::object_detection::protos::Loss_EqualizationLoss* Loss::release_equalization_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.equalization_loss)
  _has_bits_[0] &= ~0x00000010u;
  ::object_detection::protos::Loss_EqualizationLoss* temp = equalization_loss_;
  equalization_loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Loss_EqualizationLoss* Loss::mutable_equalization_loss() {
  _has_bits_[0] |= 0x00000010u;
  if (equalization_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Loss_EqualizationLoss>(GetArenaNoVirtual());
    equalization_loss_ = p;
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.equalization_loss)
  return equalization_loss_;
}
inline void Loss::set_allocated_equalization_loss(::object_detection::protos::Loss_EqualizationLoss* equalization_loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete equalization_loss_;
  }
  if (equalization_loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      equalization_loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, equalization_loss, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  equalization_loss_ = equalization_loss;
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.Loss.equalization_loss)
}

// optional .object_detection.protos.Loss.ExpectedLossWeights expected_loss_weights = 18 [default = NONE];
inline bool Loss::has_expected_loss_weights() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Loss::clear_expected_loss_weights() {
  expected_loss_weights_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::object_detection::protos::Loss_ExpectedLossWeights Loss::expected_loss_weights() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.expected_loss_weights)
  return static_cast< ::object_detection::protos::Loss_ExpectedLossWeights >(expected_loss_weights_);
}
inline void Loss::set_expected_loss_weights(::object_detection::protos::Loss_ExpectedLossWeights value) {
  assert(::object_detection::protos::Loss_ExpectedLossWeights_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  expected_loss_weights_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.expected_loss_weights)
}

// optional float min_num_negative_samples = 19 [default = 0];
inline bool Loss::has_min_num_negative_samples() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Loss::clear_min_num_negative_samples() {
  min_num_negative_samples_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline float Loss::min_num_negative_samples() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.min_num_negative_samples)
  return min_num_negative_samples_;
}
inline void Loss::set_min_num_negative_samples(float value) {
  _has_bits_[0] |= 0x00000040u;
  min_num_negative_samples_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.min_num_negative_samples)
}

// optional float desired_negative_sampling_ratio = 20 [default = 3];
inline bool Loss::has_desired_negative_sampling_ratio() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Loss::clear_desired_negative_sampling_ratio() {
  desired_negative_sampling_ratio_ = 3;
  _has_bits_[0] &= ~0x00000080u;
}
inline float Loss::desired_negative_sampling_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.desired_negative_sampling_ratio)
  return desired_negative_sampling_ratio_;
}
inline void Loss::set_desired_negative_sampling_ratio(float value) {
  _has_bits_[0] |= 0x00000080u;
  desired_negative_sampling_ratio_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.desired_negative_sampling_ratio)
}

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

// LocalizationLoss

// optional .object_detection.protos.WeightedL2LocalizationLoss weighted_l2 = 1;
inline bool LocalizationLoss::has_weighted_l2() const {
  return localization_loss_case() == kWeightedL2;
}
inline void LocalizationLoss::set_has_weighted_l2() {
  _oneof_case_[0] = kWeightedL2;
}
inline void LocalizationLoss::clear_weighted_l2() {
  if (has_weighted_l2()) {
    delete localization_loss_.weighted_l2_;
    clear_has_localization_loss();
  }
}
inline ::object_detection::protos::WeightedL2LocalizationLoss* LocalizationLoss::release_weighted_l2() {
  // @@protoc_insertion_point(field_release:object_detection.protos.LocalizationLoss.weighted_l2)
  if (has_weighted_l2()) {
    clear_has_localization_loss();
      ::object_detection::protos::WeightedL2LocalizationLoss* temp = localization_loss_.weighted_l2_;
    localization_loss_.weighted_l2_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedL2LocalizationLoss& LocalizationLoss::weighted_l2() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.LocalizationLoss.weighted_l2)
  return has_weighted_l2()
      ? *localization_loss_.weighted_l2_
      : *reinterpret_cast< ::object_detection::protos::WeightedL2LocalizationLoss*>(&::object_detection::protos::_WeightedL2LocalizationLoss_default_instance_);
}
inline ::object_detection::protos::WeightedL2LocalizationLoss* LocalizationLoss::mutable_weighted_l2() {
  if (!has_weighted_l2()) {
    clear_localization_loss();
    set_has_weighted_l2();
    localization_loss_.weighted_l2_ = CreateMaybeMessage< ::object_detection::protos::WeightedL2LocalizationLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.LocalizationLoss.weighted_l2)
  return localization_loss_.weighted_l2_;
}

// optional .object_detection.protos.WeightedSmoothL1LocalizationLoss weighted_smooth_l1 = 2;
inline bool LocalizationLoss::has_weighted_smooth_l1() const {
  return localization_loss_case() == kWeightedSmoothL1;
}
inline void LocalizationLoss::set_has_weighted_smooth_l1() {
  _oneof_case_[0] = kWeightedSmoothL1;
}
inline void LocalizationLoss::clear_weighted_smooth_l1() {
  if (has_weighted_smooth_l1()) {
    delete localization_loss_.weighted_smooth_l1_;
    clear_has_localization_loss();
  }
}
inline ::object_detection::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::release_weighted_smooth_l1() {
  // @@protoc_insertion_point(field_release:object_detection.protos.LocalizationLoss.weighted_smooth_l1)
  if (has_weighted_smooth_l1()) {
    clear_has_localization_loss();
      ::object_detection::protos::WeightedSmoothL1LocalizationLoss* temp = localization_loss_.weighted_smooth_l1_;
    localization_loss_.weighted_smooth_l1_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSmoothL1LocalizationLoss& LocalizationLoss::weighted_smooth_l1() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.LocalizationLoss.weighted_smooth_l1)
  return has_weighted_smooth_l1()
      ? *localization_loss_.weighted_smooth_l1_
      : *reinterpret_cast< ::object_detection::protos::WeightedSmoothL1LocalizationLoss*>(&::object_detection::protos::_WeightedSmoothL1LocalizationLoss_default_instance_);
}
inline ::object_detection::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::mutable_weighted_smooth_l1() {
  if (!has_weighted_smooth_l1()) {
    clear_localization_loss();
    set_has_weighted_smooth_l1();
    localization_loss_.weighted_smooth_l1_ = CreateMaybeMessage< ::object_detection::protos::WeightedSmoothL1LocalizationLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.LocalizationLoss.weighted_smooth_l1)
  return localization_loss_.weighted_smooth_l1_;
}

// optional .object_detection.protos.WeightedIOULocalizationLoss weighted_iou = 3;
inline bool LocalizationLoss::has_weighted_iou() const {
  return localization_loss_case() == kWeightedIou;
}
inline void LocalizationLoss::set_has_weighted_iou() {
  _oneof_case_[0] = kWeightedIou;
}
inline void LocalizationLoss::clear_weighted_iou() {
  if (has_weighted_iou()) {
    delete localization_loss_.weighted_iou_;
    clear_has_localization_loss();
  }
}
inline ::object_detection::protos::WeightedIOULocalizationLoss* LocalizationLoss::release_weighted_iou() {
  // @@protoc_insertion_point(field_release:object_detection.protos.LocalizationLoss.weighted_iou)
  if (has_weighted_iou()) {
    clear_has_localization_loss();
      ::object_detection::protos::WeightedIOULocalizationLoss* temp = localization_loss_.weighted_iou_;
    localization_loss_.weighted_iou_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedIOULocalizationLoss& LocalizationLoss::weighted_iou() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.LocalizationLoss.weighted_iou)
  return has_weighted_iou()
      ? *localization_loss_.weighted_iou_
      : *reinterpret_cast< ::object_detection::protos::WeightedIOULocalizationLoss*>(&::object_detection::protos::_WeightedIOULocalizationLoss_default_instance_);
}
inline ::object_detection::protos::WeightedIOULocalizationLoss* LocalizationLoss::mutable_weighted_iou() {
  if (!has_weighted_iou()) {
    clear_localization_loss();
    set_has_weighted_iou();
    localization_loss_.weighted_iou_ = CreateMaybeMessage< ::object_detection::protos::WeightedIOULocalizationLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.LocalizationLoss.weighted_iou)
  return localization_loss_.weighted_iou_;
}

inline bool LocalizationLoss::has_localization_loss() const {
  return localization_loss_case() != LOCALIZATION_LOSS_NOT_SET;
}
inline void LocalizationLoss::clear_has_localization_loss() {
  _oneof_case_[0] = LOCALIZATION_LOSS_NOT_SET;
}
inline LocalizationLoss::LocalizationLossCase LocalizationLoss::localization_loss_case() const {
  return LocalizationLoss::LocalizationLossCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// WeightedL2LocalizationLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool WeightedL2LocalizationLoss::has_anchorwise_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeightedL2LocalizationLoss::clear_anchorwise_output() {
  anchorwise_output_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedL2LocalizationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedL2LocalizationLoss.anchorwise_output)
  return anchorwise_output_;
}
inline void WeightedL2LocalizationLoss::set_anchorwise_output(bool value) {
  _has_bits_[0] |= 0x00000001u;
  anchorwise_output_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedL2LocalizationLoss.anchorwise_output)
}

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

// WeightedSmoothL1LocalizationLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool WeightedSmoothL1LocalizationLoss::has_anchorwise_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeightedSmoothL1LocalizationLoss::clear_anchorwise_output() {
  anchorwise_output_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedSmoothL1LocalizationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSmoothL1LocalizationLoss.anchorwise_output)
  return anchorwise_output_;
}
inline void WeightedSmoothL1LocalizationLoss::set_anchorwise_output(bool value) {
  _has_bits_[0] |= 0x00000001u;
  anchorwise_output_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSmoothL1LocalizationLoss.anchorwise_output)
}

// optional float delta = 2 [default = 1];
inline bool WeightedSmoothL1LocalizationLoss::has_delta() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WeightedSmoothL1LocalizationLoss::clear_delta() {
  delta_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline float WeightedSmoothL1LocalizationLoss::delta() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSmoothL1LocalizationLoss.delta)
  return delta_;
}
inline void WeightedSmoothL1LocalizationLoss::set_delta(float value) {
  _has_bits_[0] |= 0x00000002u;
  delta_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSmoothL1LocalizationLoss.delta)
}

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

// WeightedIOULocalizationLoss

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

// ClassificationLoss

// optional .object_detection.protos.WeightedSigmoidClassificationLoss weighted_sigmoid = 1;
inline bool ClassificationLoss::has_weighted_sigmoid() const {
  return classification_loss_case() == kWeightedSigmoid;
}
inline void ClassificationLoss::set_has_weighted_sigmoid() {
  _oneof_case_[0] = kWeightedSigmoid;
}
inline void ClassificationLoss::clear_weighted_sigmoid() {
  if (has_weighted_sigmoid()) {
    delete classification_loss_.weighted_sigmoid_;
    clear_has_classification_loss();
  }
}
inline ::object_detection::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::release_weighted_sigmoid() {
  // @@protoc_insertion_point(field_release:object_detection.protos.ClassificationLoss.weighted_sigmoid)
  if (has_weighted_sigmoid()) {
    clear_has_classification_loss();
      ::object_detection::protos::WeightedSigmoidClassificationLoss* temp = classification_loss_.weighted_sigmoid_;
    classification_loss_.weighted_sigmoid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSigmoidClassificationLoss& ClassificationLoss::weighted_sigmoid() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_sigmoid)
  return has_weighted_sigmoid()
      ? *classification_loss_.weighted_sigmoid_
      : *reinterpret_cast< ::object_detection::protos::WeightedSigmoidClassificationLoss*>(&::object_detection::protos::_WeightedSigmoidClassificationLoss_default_instance_);
}
inline ::object_detection::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::mutable_weighted_sigmoid() {
  if (!has_weighted_sigmoid()) {
    clear_classification_loss();
    set_has_weighted_sigmoid();
    classification_loss_.weighted_sigmoid_ = CreateMaybeMessage< ::object_detection::protos::WeightedSigmoidClassificationLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_sigmoid)
  return classification_loss_.weighted_sigmoid_;
}

// optional .object_detection.protos.WeightedSoftmaxClassificationLoss weighted_softmax = 2;
inline bool ClassificationLoss::has_weighted_softmax() const {
  return classification_loss_case() == kWeightedSoftmax;
}
inline void ClassificationLoss::set_has_weighted_softmax() {
  _oneof_case_[0] = kWeightedSoftmax;
}
inline void ClassificationLoss::clear_weighted_softmax() {
  if (has_weighted_softmax()) {
    delete classification_loss_.weighted_softmax_;
    clear_has_classification_loss();
  }
}
inline ::object_detection::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::release_weighted_softmax() {
  // @@protoc_insertion_point(field_release:object_detection.protos.ClassificationLoss.weighted_softmax)
  if (has_weighted_softmax()) {
    clear_has_classification_loss();
      ::object_detection::protos::WeightedSoftmaxClassificationLoss* temp = classification_loss_.weighted_softmax_;
    classification_loss_.weighted_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSoftmaxClassificationLoss& ClassificationLoss::weighted_softmax() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_softmax)
  return has_weighted_softmax()
      ? *classification_loss_.weighted_softmax_
      : *reinterpret_cast< ::object_detection::protos::WeightedSoftmaxClassificationLoss*>(&::object_detection::protos::_WeightedSoftmaxClassificationLoss_default_instance_);
}
inline ::object_detection::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::mutable_weighted_softmax() {
  if (!has_weighted_softmax()) {
    clear_classification_loss();
    set_has_weighted_softmax();
    classification_loss_.weighted_softmax_ = CreateMaybeMessage< ::object_detection::protos::WeightedSoftmaxClassificationLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_softmax)
  return classification_loss_.weighted_softmax_;
}

// optional .object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss weighted_logits_softmax = 5;
inline bool ClassificationLoss::has_weighted_logits_softmax() const {
  return classification_loss_case() == kWeightedLogitsSoftmax;
}
inline void ClassificationLoss::set_has_weighted_logits_softmax() {
  _oneof_case_[0] = kWeightedLogitsSoftmax;
}
inline void ClassificationLoss::clear_weighted_logits_softmax() {
  if (has_weighted_logits_softmax()) {
    delete classification_loss_.weighted_logits_softmax_;
    clear_has_classification_loss();
  }
}
inline ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* ClassificationLoss::release_weighted_logits_softmax() {
  // @@protoc_insertion_point(field_release:object_detection.protos.ClassificationLoss.weighted_logits_softmax)
  if (has_weighted_logits_softmax()) {
    clear_has_classification_loss();
      ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* temp = classification_loss_.weighted_logits_softmax_;
    classification_loss_.weighted_logits_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss& ClassificationLoss::weighted_logits_softmax() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_logits_softmax)
  return has_weighted_logits_softmax()
      ? *classification_loss_.weighted_logits_softmax_
      : *reinterpret_cast< ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss*>(&::object_detection::protos::_WeightedSoftmaxClassificationAgainstLogitsLoss_default_instance_);
}
inline ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* ClassificationLoss::mutable_weighted_logits_softmax() {
  if (!has_weighted_logits_softmax()) {
    clear_classification_loss();
    set_has_weighted_logits_softmax();
    classification_loss_.weighted_logits_softmax_ = CreateMaybeMessage< ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_logits_softmax)
  return classification_loss_.weighted_logits_softmax_;
}

// optional .object_detection.protos.BootstrappedSigmoidClassificationLoss bootstrapped_sigmoid = 3;
inline bool ClassificationLoss::has_bootstrapped_sigmoid() const {
  return classification_loss_case() == kBootstrappedSigmoid;
}
inline void ClassificationLoss::set_has_bootstrapped_sigmoid() {
  _oneof_case_[0] = kBootstrappedSigmoid;
}
inline void ClassificationLoss::clear_bootstrapped_sigmoid() {
  if (has_bootstrapped_sigmoid()) {
    delete classification_loss_.bootstrapped_sigmoid_;
    clear_has_classification_loss();
  }
}
inline ::object_detection::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::release_bootstrapped_sigmoid() {
  // @@protoc_insertion_point(field_release:object_detection.protos.ClassificationLoss.bootstrapped_sigmoid)
  if (has_bootstrapped_sigmoid()) {
    clear_has_classification_loss();
      ::object_detection::protos::BootstrappedSigmoidClassificationLoss* temp = classification_loss_.bootstrapped_sigmoid_;
    classification_loss_.bootstrapped_sigmoid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::BootstrappedSigmoidClassificationLoss& ClassificationLoss::bootstrapped_sigmoid() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.bootstrapped_sigmoid)
  return has_bootstrapped_sigmoid()
      ? *classification_loss_.bootstrapped_sigmoid_
      : *reinterpret_cast< ::object_detection::protos::BootstrappedSigmoidClassificationLoss*>(&::object_detection::protos::_BootstrappedSigmoidClassificationLoss_default_instance_);
}
inline ::object_detection::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::mutable_bootstrapped_sigmoid() {
  if (!has_bootstrapped_sigmoid()) {
    clear_classification_loss();
    set_has_bootstrapped_sigmoid();
    classification_loss_.bootstrapped_sigmoid_ = CreateMaybeMessage< ::object_detection::protos::BootstrappedSigmoidClassificationLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.bootstrapped_sigmoid)
  return classification_loss_.bootstrapped_sigmoid_;
}

// optional .object_detection.protos.SigmoidFocalClassificationLoss weighted_sigmoid_focal = 4;
inline bool ClassificationLoss::has_weighted_sigmoid_focal() const {
  return classification_loss_case() == kWeightedSigmoidFocal;
}
inline void ClassificationLoss::set_has_weighted_sigmoid_focal() {
  _oneof_case_[0] = kWeightedSigmoidFocal;
}
inline void ClassificationLoss::clear_weighted_sigmoid_focal() {
  if (has_weighted_sigmoid_focal()) {
    delete classification_loss_.weighted_sigmoid_focal_;
    clear_has_classification_loss();
  }
}
inline ::object_detection::protos::SigmoidFocalClassificationLoss* ClassificationLoss::release_weighted_sigmoid_focal() {
  // @@protoc_insertion_point(field_release:object_detection.protos.ClassificationLoss.weighted_sigmoid_focal)
  if (has_weighted_sigmoid_focal()) {
    clear_has_classification_loss();
      ::object_detection::protos::SigmoidFocalClassificationLoss* temp = classification_loss_.weighted_sigmoid_focal_;
    classification_loss_.weighted_sigmoid_focal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::SigmoidFocalClassificationLoss& ClassificationLoss::weighted_sigmoid_focal() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_sigmoid_focal)
  return has_weighted_sigmoid_focal()
      ? *classification_loss_.weighted_sigmoid_focal_
      : *reinterpret_cast< ::object_detection::protos::SigmoidFocalClassificationLoss*>(&::object_detection::protos::_SigmoidFocalClassificationLoss_default_instance_);
}
inline ::object_detection::protos::SigmoidFocalClassificationLoss* ClassificationLoss::mutable_weighted_sigmoid_focal() {
  if (!has_weighted_sigmoid_focal()) {
    clear_classification_loss();
    set_has_weighted_sigmoid_focal();
    classification_loss_.weighted_sigmoid_focal_ = CreateMaybeMessage< ::object_detection::protos::SigmoidFocalClassificationLoss >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_sigmoid_focal)
  return classification_loss_.weighted_sigmoid_focal_;
}

inline bool ClassificationLoss::has_classification_loss() const {
  return classification_loss_case() != CLASSIFICATION_LOSS_NOT_SET;
}
inline void ClassificationLoss::clear_has_classification_loss() {
  _oneof_case_[0] = CLASSIFICATION_LOSS_NOT_SET;
}
inline ClassificationLoss::ClassificationLossCase ClassificationLoss::classification_loss_case() const {
  return ClassificationLoss::ClassificationLossCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// WeightedSigmoidClassificationLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool WeightedSigmoidClassificationLoss::has_anchorwise_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeightedSigmoidClassificationLoss::clear_anchorwise_output() {
  anchorwise_output_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedSigmoidClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSigmoidClassificationLoss.anchorwise_output)
  return anchorwise_output_;
}
inline void WeightedSigmoidClassificationLoss::set_anchorwise_output(bool value) {
  _has_bits_[0] |= 0x00000001u;
  anchorwise_output_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSigmoidClassificationLoss.anchorwise_output)
}

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

// SigmoidFocalClassificationLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool SigmoidFocalClassificationLoss::has_anchorwise_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SigmoidFocalClassificationLoss::clear_anchorwise_output() {
  anchorwise_output_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool SigmoidFocalClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SigmoidFocalClassificationLoss.anchorwise_output)
  return anchorwise_output_;
}
inline void SigmoidFocalClassificationLoss::set_anchorwise_output(bool value) {
  _has_bits_[0] |= 0x00000001u;
  anchorwise_output_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.SigmoidFocalClassificationLoss.anchorwise_output)
}

// optional float gamma = 2 [default = 2];
inline bool SigmoidFocalClassificationLoss::has_gamma() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SigmoidFocalClassificationLoss::clear_gamma() {
  gamma_ = 2;
  _has_bits_[0] &= ~0x00000004u;
}
inline float SigmoidFocalClassificationLoss::gamma() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SigmoidFocalClassificationLoss.gamma)
  return gamma_;
}
inline void SigmoidFocalClassificationLoss::set_gamma(float value) {
  _has_bits_[0] |= 0x00000004u;
  gamma_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.SigmoidFocalClassificationLoss.gamma)
}

// optional float alpha = 3;
inline bool SigmoidFocalClassificationLoss::has_alpha() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SigmoidFocalClassificationLoss::clear_alpha() {
  alpha_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline float SigmoidFocalClassificationLoss::alpha() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SigmoidFocalClassificationLoss.alpha)
  return alpha_;
}
inline void SigmoidFocalClassificationLoss::set_alpha(float value) {
  _has_bits_[0] |= 0x00000002u;
  alpha_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.SigmoidFocalClassificationLoss.alpha)
}

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

// WeightedSoftmaxClassificationLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool WeightedSoftmaxClassificationLoss::has_anchorwise_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeightedSoftmaxClassificationLoss::clear_anchorwise_output() {
  anchorwise_output_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedSoftmaxClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSoftmaxClassificationLoss.anchorwise_output)
  return anchorwise_output_;
}
inline void WeightedSoftmaxClassificationLoss::set_anchorwise_output(bool value) {
  _has_bits_[0] |= 0x00000001u;
  anchorwise_output_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSoftmaxClassificationLoss.anchorwise_output)
}

// optional float logit_scale = 2 [default = 1];
inline bool WeightedSoftmaxClassificationLoss::has_logit_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WeightedSoftmaxClassificationLoss::clear_logit_scale() {
  logit_scale_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline float WeightedSoftmaxClassificationLoss::logit_scale() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSoftmaxClassificationLoss.logit_scale)
  return logit_scale_;
}
inline void WeightedSoftmaxClassificationLoss::set_logit_scale(float value) {
  _has_bits_[0] |= 0x00000002u;
  logit_scale_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSoftmaxClassificationLoss.logit_scale)
}

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

// WeightedSoftmaxClassificationAgainstLogitsLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool WeightedSoftmaxClassificationAgainstLogitsLoss::has_anchorwise_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeightedSoftmaxClassificationAgainstLogitsLoss::clear_anchorwise_output() {
  anchorwise_output_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedSoftmaxClassificationAgainstLogitsLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss.anchorwise_output)
  return anchorwise_output_;
}
inline void WeightedSoftmaxClassificationAgainstLogitsLoss::set_anchorwise_output(bool value) {
  _has_bits_[0] |= 0x00000001u;
  anchorwise_output_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss.anchorwise_output)
}

// optional float logit_scale = 2 [default = 1];
inline bool WeightedSoftmaxClassificationAgainstLogitsLoss::has_logit_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WeightedSoftmaxClassificationAgainstLogitsLoss::clear_logit_scale() {
  logit_scale_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline float WeightedSoftmaxClassificationAgainstLogitsLoss::logit_scale() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss.logit_scale)
  return logit_scale_;
}
inline void WeightedSoftmaxClassificationAgainstLogitsLoss::set_logit_scale(float value) {
  _has_bits_[0] |= 0x00000002u;
  logit_scale_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss.logit_scale)
}

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

// BootstrappedSigmoidClassificationLoss

// optional float alpha = 1;
inline bool BootstrappedSigmoidClassificationLoss::has_alpha() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BootstrappedSigmoidClassificationLoss::clear_alpha() {
  alpha_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline float BootstrappedSigmoidClassificationLoss::alpha() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BootstrappedSigmoidClassificationLoss.alpha)
  return alpha_;
}
inline void BootstrappedSigmoidClassificationLoss::set_alpha(float value) {
  _has_bits_[0] |= 0x00000001u;
  alpha_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BootstrappedSigmoidClassificationLoss.alpha)
}

// optional bool hard_bootstrap = 2 [default = false];
inline bool BootstrappedSigmoidClassificationLoss::has_hard_bootstrap() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BootstrappedSigmoidClassificationLoss::clear_hard_bootstrap() {
  hard_bootstrap_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool BootstrappedSigmoidClassificationLoss::hard_bootstrap() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BootstrappedSigmoidClassificationLoss.hard_bootstrap)
  return hard_bootstrap_;
}
inline void BootstrappedSigmoidClassificationLoss::set_hard_bootstrap(bool value) {
  _has_bits_[0] |= 0x00000002u;
  hard_bootstrap_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BootstrappedSigmoidClassificationLoss.hard_bootstrap)
}

// optional bool anchorwise_output = 3 [default = false];
inline bool BootstrappedSigmoidClassificationLoss::has_anchorwise_output() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BootstrappedSigmoidClassificationLoss::clear_anchorwise_output() {
  anchorwise_output_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool BootstrappedSigmoidClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BootstrappedSigmoidClassificationLoss.anchorwise_output)
  return anchorwise_output_;
}
inline void BootstrappedSigmoidClassificationLoss::set_anchorwise_output(bool value) {
  _has_bits_[0] |= 0x00000004u;
  anchorwise_output_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.BootstrappedSigmoidClassificationLoss.anchorwise_output)
}

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

// HardExampleMiner

// optional int32 num_hard_examples = 1 [default = 64];
inline bool HardExampleMiner::has_num_hard_examples() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void HardExampleMiner::clear_num_hard_examples() {
  num_hard_examples_ = 64;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 HardExampleMiner::num_hard_examples() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.num_hard_examples)
  return num_hard_examples_;
}
inline void HardExampleMiner::set_num_hard_examples(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  num_hard_examples_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.HardExampleMiner.num_hard_examples)
}

// optional float iou_threshold = 2 [default = 0.7];
inline bool HardExampleMiner::has_iou_threshold() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void HardExampleMiner::clear_iou_threshold() {
  iou_threshold_ = 0.7f;
  _has_bits_[0] &= ~0x00000010u;
}
inline float HardExampleMiner::iou_threshold() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.iou_threshold)
  return iou_threshold_;
}
inline void HardExampleMiner::set_iou_threshold(float value) {
  _has_bits_[0] |= 0x00000010u;
  iou_threshold_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.HardExampleMiner.iou_threshold)
}

// optional .object_detection.protos.HardExampleMiner.LossType loss_type = 3 [default = BOTH];
inline bool HardExampleMiner::has_loss_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HardExampleMiner::clear_loss_type() {
  loss_type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::object_detection::protos::HardExampleMiner_LossType HardExampleMiner::loss_type() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.loss_type)
  return static_cast< ::object_detection::protos::HardExampleMiner_LossType >(loss_type_);
}
inline void HardExampleMiner::set_loss_type(::object_detection::protos::HardExampleMiner_LossType value) {
  assert(::object_detection::protos::HardExampleMiner_LossType_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  loss_type_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.HardExampleMiner.loss_type)
}

// optional int32 max_negatives_per_positive = 4 [default = 0];
inline bool HardExampleMiner::has_max_negatives_per_positive() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HardExampleMiner::clear_max_negatives_per_positive() {
  max_negatives_per_positive_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 HardExampleMiner::max_negatives_per_positive() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.max_negatives_per_positive)
  return max_negatives_per_positive_;
}
inline void HardExampleMiner::set_max_negatives_per_positive(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  max_negatives_per_positive_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.HardExampleMiner.max_negatives_per_positive)
}

// optional int32 min_negatives_per_image = 5 [default = 0];
inline bool HardExampleMiner::has_min_negatives_per_image() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HardExampleMiner::clear_min_negatives_per_image() {
  min_negatives_per_image_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 HardExampleMiner::min_negatives_per_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.min_negatives_per_image)
  return min_negatives_per_image_;
}
inline void HardExampleMiner::set_min_negatives_per_image(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  min_negatives_per_image_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.HardExampleMiner.min_negatives_per_image)
}

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

// RandomExampleSampler

// optional float positive_sample_fraction = 1 [default = 0.01];
inline bool RandomExampleSampler::has_positive_sample_fraction() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RandomExampleSampler::clear_positive_sample_fraction() {
  positive_sample_fraction_ = 0.01f;
  _has_bits_[0] &= ~0x00000001u;
}
inline float RandomExampleSampler::positive_sample_fraction() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomExampleSampler.positive_sample_fraction)
  return positive_sample_fraction_;
}
inline void RandomExampleSampler::set_positive_sample_fraction(float value) {
  _has_bits_[0] |= 0x00000001u;
  positive_sample_fraction_ = value;
  // @@protoc_insertion_point(field_set:object_detection.protos.RandomExampleSampler.positive_sample_fraction)
}

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace object_detection

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::object_detection::protos::Loss_ExpectedLossWeights> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::object_detection::protos::Loss_ExpectedLossWeights>() {
  return ::object_detection::protos::Loss_ExpectedLossWeights_descriptor();
}
template <> struct is_proto_enum< ::object_detection::protos::HardExampleMiner_LossType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::object_detection::protos::HardExampleMiner_LossType>() {
  return ::object_detection::protos::HardExampleMiner_LossType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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