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

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_bases.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_object_5fdetection_2fprotos_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 uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_object_5fdetection_2fprotos_2flosses_2eproto;
namespace object_detection {
namespace protos {
class BootstrappedSigmoidClassificationLoss;
struct BootstrappedSigmoidClassificationLossDefaultTypeInternal;
extern BootstrappedSigmoidClassificationLossDefaultTypeInternal _BootstrappedSigmoidClassificationLoss_default_instance_;
class ClassificationLoss;
struct ClassificationLossDefaultTypeInternal;
extern ClassificationLossDefaultTypeInternal _ClassificationLoss_default_instance_;
class HardExampleMiner;
struct HardExampleMinerDefaultTypeInternal;
extern HardExampleMinerDefaultTypeInternal _HardExampleMiner_default_instance_;
class LocalizationLoss;
struct LocalizationLossDefaultTypeInternal;
extern LocalizationLossDefaultTypeInternal _LocalizationLoss_default_instance_;
class Loss;
struct LossDefaultTypeInternal;
extern LossDefaultTypeInternal _Loss_default_instance_;
class Loss_EqualizationLoss;
struct Loss_EqualizationLossDefaultTypeInternal;
extern Loss_EqualizationLossDefaultTypeInternal _Loss_EqualizationLoss_default_instance_;
class RandomExampleSampler;
struct RandomExampleSamplerDefaultTypeInternal;
extern RandomExampleSamplerDefaultTypeInternal _RandomExampleSampler_default_instance_;
class SigmoidFocalClassificationLoss;
struct SigmoidFocalClassificationLossDefaultTypeInternal;
extern SigmoidFocalClassificationLossDefaultTypeInternal _SigmoidFocalClassificationLoss_default_instance_;
class WeightedIOULocalizationLoss;
struct WeightedIOULocalizationLossDefaultTypeInternal;
extern WeightedIOULocalizationLossDefaultTypeInternal _WeightedIOULocalizationLoss_default_instance_;
class WeightedL2LocalizationLoss;
struct WeightedL2LocalizationLossDefaultTypeInternal;
extern WeightedL2LocalizationLossDefaultTypeInternal _WeightedL2LocalizationLoss_default_instance_;
class WeightedSigmoidClassificationLoss;
struct WeightedSigmoidClassificationLossDefaultTypeInternal;
extern WeightedSigmoidClassificationLossDefaultTypeInternal _WeightedSigmoidClassificationLoss_default_instance_;
class WeightedSmoothL1LocalizationLoss;
struct WeightedSmoothL1LocalizationLossDefaultTypeInternal;
extern WeightedSmoothL1LocalizationLossDefaultTypeInternal _WeightedSmoothL1LocalizationLoss_default_instance_;
class WeightedSoftmaxClassificationAgainstLogitsLoss;
struct WeightedSoftmaxClassificationAgainstLogitsLossDefaultTypeInternal;
extern WeightedSoftmaxClassificationAgainstLogitsLossDefaultTypeInternal _WeightedSoftmaxClassificationAgainstLogitsLoss_default_instance_;
class WeightedSoftmaxClassificationLoss;
struct 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HardExampleMiner_LossType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HardExampleMiner_LossType>(
    HardExampleMiner_LossType_descriptor(), name, value);
}
// ===================================================================

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kExcludePrefixesFieldNumber = 2,
    kWeightFieldNumber = 1,
  };
  // repeated string exclude_prefixes = 2;
  int exclude_prefixes_size() const;
  private:
  int _internal_exclude_prefixes_size() const;
  public:
  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();
  private:
  const std::string& _internal_exclude_prefixes(int index) const;
  std::string* _internal_add_exclude_prefixes();
  public:

  // optional float weight = 1 [default = 0];
  bool has_weight() const;
  private:
  bool _internal_has_weight() const;
  public:
  void clear_weight();
  float weight() const;
  void set_weight(float value);
  private:
  float _internal_weight() const;
  void _internal_set_weight(float value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  typedef 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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;
  private:
  bool _internal_has_localization_loss() const;
  public:
  void clear_localization_loss();
  const ::object_detection::protos::LocalizationLoss& localization_loss() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::LocalizationLoss& _internal_localization_loss() const;
  ::object_detection::protos::LocalizationLoss* _internal_mutable_localization_loss();
  public:
  void unsafe_arena_set_allocated_localization_loss(
      ::object_detection::protos::LocalizationLoss* localization_loss);
  ::object_detection::protos::LocalizationLoss* unsafe_arena_release_localization_loss();

  // optional .object_detection.protos.ClassificationLoss classification_loss = 2;
  bool has_classification_loss() const;
  private:
  bool _internal_has_classification_loss() const;
  public:
  void clear_classification_loss();
  const ::object_detection::protos::ClassificationLoss& classification_loss() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::ClassificationLoss& _internal_classification_loss() const;
  ::object_detection::protos::ClassificationLoss* _internal_mutable_classification_loss();
  public:
  void unsafe_arena_set_allocated_classification_loss(
      ::object_detection::protos::ClassificationLoss* classification_loss);
  ::object_detection::protos::ClassificationLoss* unsafe_arena_release_classification_loss();

  // optional .object_detection.protos.HardExampleMiner hard_example_miner = 3;
  bool has_hard_example_miner() const;
  private:
  bool _internal_has_hard_example_miner() const;
  public:
  void clear_hard_example_miner();
  const ::object_detection::protos::HardExampleMiner& hard_example_miner() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::HardExampleMiner& _internal_hard_example_miner() const;
  ::object_detection::protos::HardExampleMiner* _internal_mutable_hard_example_miner();
  public:
  void unsafe_arena_set_allocated_hard_example_miner(
      ::object_detection::protos::HardExampleMiner* hard_example_miner);
  ::object_detection::protos::HardExampleMiner* unsafe_arena_release_hard_example_miner();

  // optional .object_detection.protos.RandomExampleSampler random_example_sampler = 6;
  bool has_random_example_sampler() const;
  private:
  bool _internal_has_random_example_sampler() const;
  public:
  void clear_random_example_sampler();
  const ::object_detection::protos::RandomExampleSampler& random_example_sampler() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::RandomExampleSampler& _internal_random_example_sampler() const;
  ::object_detection::protos::RandomExampleSampler* _internal_mutable_random_example_sampler();
  public:
  void unsafe_arena_set_allocated_random_example_sampler(
      ::object_detection::protos::RandomExampleSampler* random_example_sampler);
  ::object_detection::protos::RandomExampleSampler* unsafe_arena_release_random_example_sampler();

  // optional .object_detection.protos.Loss.EqualizationLoss equalization_loss = 7;
  bool has_equalization_loss() const;
  private:
  bool _internal_has_equalization_loss() const;
  public:
  void clear_equalization_loss();
  const ::object_detection::protos::Loss_EqualizationLoss& equalization_loss() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::Loss_EqualizationLoss& _internal_equalization_loss() const;
  ::object_detection::protos::Loss_EqualizationLoss* _internal_mutable_equalization_loss();
  public:
  void unsafe_arena_set_allocated_equalization_loss(
      ::object_detection::protos::Loss_EqualizationLoss* equalization_loss);
  ::object_detection::protos::Loss_EqualizationLoss* unsafe_arena_release_equalization_loss();

  // optional .object_detection.protos.Loss.ExpectedLossWeights expected_loss_weights = 18 [default = NONE];
  bool has_expected_loss_weights() const;
  private:
  bool _internal_has_expected_loss_weights() const;
  public:
  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);
  private:
  ::object_detection::protos::Loss_ExpectedLossWeights _internal_expected_loss_weights() const;
  void _internal_set_expected_loss_weights(::object_detection::protos::Loss_ExpectedLossWeights value);
  public:

  // optional float min_num_negative_samples = 19 [default = 0];
  bool has_min_num_negative_samples() const;
  private:
  bool _internal_has_min_num_negative_samples() const;
  public:
  void clear_min_num_negative_samples();
  float min_num_negative_samples() const;
  void set_min_num_negative_samples(float value);
  private:
  float _internal_min_num_negative_samples() const;
  void _internal_set_min_num_negative_samples(float value);
  public:

  // optional float desired_negative_sampling_ratio = 20 [default = 3];
  bool has_desired_negative_sampling_ratio() const;
  private:
  bool _internal_has_desired_negative_sampling_ratio() const;
  public:
  void clear_desired_negative_sampling_ratio();
  float desired_negative_sampling_ratio() const;
  void set_desired_negative_sampling_ratio(float value);
  private:
  float _internal_desired_negative_sampling_ratio() const;
  void _internal_set_desired_negative_sampling_ratio(float value);
  public:

  // optional float classification_weight = 4 [default = 1];
  bool has_classification_weight() const;
  private:
  bool _internal_has_classification_weight() const;
  public:
  void clear_classification_weight();
  float classification_weight() const;
  void set_classification_weight(float value);
  private:
  float _internal_classification_weight() const;
  void _internal_set_classification_weight(float value);
  public:

  // optional float localization_weight = 5 [default = 1];
  bool has_localization_weight() const;
  private:
  bool _internal_has_localization_weight() const;
  public:
  void clear_localization_weight();
  float localization_weight() const;
  void set_localization_weight(float value);
  private:
  float _internal_localization_weight() const;
  void _internal_set_localization_weight(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::object_detection::protos::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_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LocalizationLoss& default_instance() {
    return *internal_default_instance();
  }
  enum LocalizationLossCase {
    kWeightedL2 = 1,
    kWeightedSmoothL1 = 2,
    kWeightedIou = 3,
    LOCALIZATION_LOSS_NOT_SET = 0,
  };

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kWeightedL2FieldNumber = 1,
    kWeightedSmoothL1FieldNumber = 2,
    kWeightedIouFieldNumber = 3,
  };
  // .object_detection.protos.WeightedL2LocalizationLoss weighted_l2 = 1;
  bool has_weighted_l2() const;
  private:
  bool _internal_has_weighted_l2() const;
  public:
  void clear_weighted_l2();
  const ::object_detection::protos::WeightedL2LocalizationLoss& weighted_l2() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::WeightedL2LocalizationLoss& _internal_weighted_l2() const;
  ::object_detection::protos::WeightedL2LocalizationLoss* _internal_mutable_weighted_l2();
  public:
  void unsafe_arena_set_allocated_weighted_l2(
      ::object_detection::protos::WeightedL2LocalizationLoss* weighted_l2);
  ::object_detection::protos::WeightedL2LocalizationLoss* unsafe_arena_release_weighted_l2();

  // .object_detection.protos.WeightedSmoothL1LocalizationLoss weighted_smooth_l1 = 2;
  bool has_weighted_smooth_l1() const;
  private:
  bool _internal_has_weighted_smooth_l1() const;
  public:
  void clear_weighted_smooth_l1();
  const ::object_detection::protos::WeightedSmoothL1LocalizationLoss& weighted_smooth_l1() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::WeightedSmoothL1LocalizationLoss& _internal_weighted_smooth_l1() const;
  ::object_detection::protos::WeightedSmoothL1LocalizationLoss* _internal_mutable_weighted_smooth_l1();
  public:
  void unsafe_arena_set_allocated_weighted_smooth_l1(
      ::object_detection::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1);
  ::object_detection::protos::WeightedSmoothL1LocalizationLoss* unsafe_arena_release_weighted_smooth_l1();

  // .object_detection.protos.WeightedIOULocalizationLoss weighted_iou = 3;
  bool has_weighted_iou() const;
  private:
  bool _internal_has_weighted_iou() const;
  public:
  void clear_weighted_iou();
  const ::object_detection::protos::WeightedIOULocalizationLoss& weighted_iou() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::WeightedIOULocalizationLoss& _internal_weighted_iou() const;
  ::object_detection::protos::WeightedIOULocalizationLoss* _internal_mutable_weighted_iou();
  public:
  void unsafe_arena_set_allocated_weighted_iou(
      ::object_detection::protos::WeightedIOULocalizationLoss* weighted_iou);
  ::object_detection::protos::WeightedIOULocalizationLoss* unsafe_arena_release_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();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union LocalizationLossUnion {
      constexpr LocalizationLossUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::object_detection::protos::WeightedL2LocalizationLoss* weighted_l2_;
      ::object_detection::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1_;
      ::object_detection::protos::WeightedIOULocalizationLoss* weighted_iou_;
    } localization_loss_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // optional float delta = 2 [default = 1];
  bool has_delta() const;
  private:
  bool _internal_has_delta() const;
  public:
  void clear_delta();
  float delta() const;
  void set_delta(float value);
  private:
  float _internal_delta() const;
  void _internal_set_delta(float value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ClassificationLoss& default_instance() {
    return *internal_default_instance();
  }
  enum ClassificationLossCase {
    kWeightedSigmoid = 1,
    kWeightedSoftmax = 2,
    kWeightedLogitsSoftmax = 5,
    kBootstrappedSigmoid = 3,
    kWeightedSigmoidFocal = 4,
    CLASSIFICATION_LOSS_NOT_SET = 0,
  };

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kWeightedSigmoidFieldNumber = 1,
    kWeightedSoftmaxFieldNumber = 2,
    kWeightedLogitsSoftmaxFieldNumber = 5,
    kBootstrappedSigmoidFieldNumber = 3,
    kWeightedSigmoidFocalFieldNumber = 4,
  };
  // .object_detection.protos.WeightedSigmoidClassificationLoss weighted_sigmoid = 1;
  bool has_weighted_sigmoid() const;
  private:
  bool _internal_has_weighted_sigmoid() const;
  public:
  void clear_weighted_sigmoid();
  const ::object_detection::protos::WeightedSigmoidClassificationLoss& weighted_sigmoid() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::WeightedSigmoidClassificationLoss& _internal_weighted_sigmoid() const;
  ::object_detection::protos::WeightedSigmoidClassificationLoss* _internal_mutable_weighted_sigmoid();
  public:
  void unsafe_arena_set_allocated_weighted_sigmoid(
      ::object_detection::protos::WeightedSigmoidClassificationLoss* weighted_sigmoid);
  ::object_detection::protos::WeightedSigmoidClassificationLoss* unsafe_arena_release_weighted_sigmoid();

  // .object_detection.protos.WeightedSoftmaxClassificationLoss weighted_softmax = 2;
  bool has_weighted_softmax() const;
  private:
  bool _internal_has_weighted_softmax() const;
  public:
  void clear_weighted_softmax();
  const ::object_detection::protos::WeightedSoftmaxClassificationLoss& weighted_softmax() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::WeightedSoftmaxClassificationLoss& _internal_weighted_softmax() const;
  ::object_detection::protos::WeightedSoftmaxClassificationLoss* _internal_mutable_weighted_softmax();
  public:
  void unsafe_arena_set_allocated_weighted_softmax(
      ::object_detection::protos::WeightedSoftmaxClassificationLoss* weighted_softmax);
  ::object_detection::protos::WeightedSoftmaxClassificationLoss* unsafe_arena_release_weighted_softmax();

  // .object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss weighted_logits_softmax = 5;
  bool has_weighted_logits_softmax() const;
  private:
  bool _internal_has_weighted_logits_softmax() const;
  public:
  void clear_weighted_logits_softmax();
  const ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss& weighted_logits_softmax() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss& _internal_weighted_logits_softmax() const;
  ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* _internal_mutable_weighted_logits_softmax();
  public:
  void unsafe_arena_set_allocated_weighted_logits_softmax(
      ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* weighted_logits_softmax);
  ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* unsafe_arena_release_weighted_logits_softmax();

  // .object_detection.protos.BootstrappedSigmoidClassificationLoss bootstrapped_sigmoid = 3;
  bool has_bootstrapped_sigmoid() const;
  private:
  bool _internal_has_bootstrapped_sigmoid() const;
  public:
  void clear_bootstrapped_sigmoid();
  const ::object_detection::protos::BootstrappedSigmoidClassificationLoss& bootstrapped_sigmoid() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::BootstrappedSigmoidClassificationLoss& _internal_bootstrapped_sigmoid() const;
  ::object_detection::protos::BootstrappedSigmoidClassificationLoss* _internal_mutable_bootstrapped_sigmoid();
  public:
  void unsafe_arena_set_allocated_bootstrapped_sigmoid(
      ::object_detection::protos::BootstrappedSigmoidClassificationLoss* bootstrapped_sigmoid);
  ::object_detection::protos::BootstrappedSigmoidClassificationLoss* unsafe_arena_release_bootstrapped_sigmoid();

  // .object_detection.protos.SigmoidFocalClassificationLoss weighted_sigmoid_focal = 4;
  bool has_weighted_sigmoid_focal() const;
  private:
  bool _internal_has_weighted_sigmoid_focal() const;
  public:
  void clear_weighted_sigmoid_focal();
  const ::object_detection::protos::SigmoidFocalClassificationLoss& weighted_sigmoid_focal() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::object_detection::protos::SigmoidFocalClassificationLoss& _internal_weighted_sigmoid_focal() const;
  ::object_detection::protos::SigmoidFocalClassificationLoss* _internal_mutable_weighted_sigmoid_focal();
  public:
  void unsafe_arena_set_allocated_weighted_sigmoid_focal(
      ::object_detection::protos::SigmoidFocalClassificationLoss* weighted_sigmoid_focal);
  ::object_detection::protos::SigmoidFocalClassificationLoss* unsafe_arena_release_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();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ClassificationLossUnion {
      constexpr ClassificationLossUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::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_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // optional float alpha = 3;
  bool has_alpha() const;
  private:
  bool _internal_has_alpha() const;
  public:
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);
  private:
  float _internal_alpha() const;
  void _internal_set_alpha(float value);
  public:

  // optional float gamma = 2 [default = 2];
  bool has_gamma() const;
  private:
  bool _internal_has_gamma() const;
  public:
  void clear_gamma();
  float gamma() const;
  void set_gamma(float value);
  private:
  float _internal_gamma() const;
  void _internal_set_gamma(float value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // optional float logit_scale = 2 [default = 1];
  bool has_logit_scale() const;
  private:
  bool _internal_has_logit_scale() const;
  public:
  void clear_logit_scale();
  float logit_scale() const;
  void set_logit_scale(float value);
  private:
  float _internal_logit_scale() const;
  void _internal_set_logit_scale(float value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // optional float logit_scale = 2 [default = 1];
  bool has_logit_scale() const;
  private:
  bool _internal_has_logit_scale() const;
  public:
  void clear_logit_scale();
  float logit_scale() const;
  void set_logit_scale(float value);
  private:
  float _internal_logit_scale() const;
  void _internal_set_logit_scale(float value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // optional bool hard_bootstrap = 2 [default = false];
  bool has_hard_bootstrap() const;
  private:
  bool _internal_has_hard_bootstrap() const;
  public:
  void clear_hard_bootstrap();
  bool hard_bootstrap() const;
  void set_hard_bootstrap(bool value);
  private:
  bool _internal_hard_bootstrap() const;
  void _internal_set_hard_bootstrap(bool value);
  public:

  // optional bool anchorwise_output = 3 [default = false];
  bool has_anchorwise_output() const;
  private:
  bool _internal_has_anchorwise_output() const;
  public:
  void clear_anchorwise_output();
  bool anchorwise_output() const;
  void set_anchorwise_output(bool value);
  private:
  bool _internal_anchorwise_output() const;
  void _internal_set_anchorwise_output(bool value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  typedef 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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;
  private:
  bool _internal_has_loss_type() const;
  public:
  void clear_loss_type();
  ::object_detection::protos::HardExampleMiner_LossType loss_type() const;
  void set_loss_type(::object_detection::protos::HardExampleMiner_LossType value);
  private:
  ::object_detection::protos::HardExampleMiner_LossType _internal_loss_type() const;
  void _internal_set_loss_type(::object_detection::protos::HardExampleMiner_LossType value);
  public:

  // optional int32 max_negatives_per_positive = 4 [default = 0];
  bool has_max_negatives_per_positive() const;
  private:
  bool _internal_has_max_negatives_per_positive() const;
  public:
  void clear_max_negatives_per_positive();
  int32_t max_negatives_per_positive() const;
  void set_max_negatives_per_positive(int32_t value);
  private:
  int32_t _internal_max_negatives_per_positive() const;
  void _internal_set_max_negatives_per_positive(int32_t value);
  public:

  // optional int32 min_negatives_per_image = 5 [default = 0];
  bool has_min_negatives_per_image() const;
  private:
  bool _internal_has_min_negatives_per_image() const;
  public:
  void clear_min_negatives_per_image();
  int32_t min_negatives_per_image() const;
  void set_min_negatives_per_image(int32_t value);
  private:
  int32_t _internal_min_negatives_per_image() const;
  void _internal_set_min_negatives_per_image(int32_t value);
  public:

  // optional int32 num_hard_examples = 1 [default = 64];
  bool has_num_hard_examples() const;
  private:
  bool _internal_has_num_hard_examples() const;
  public:
  void clear_num_hard_examples();
  int32_t num_hard_examples() const;
  void set_num_hard_examples(int32_t value);
  private:
  int32_t _internal_num_hard_examples() const;
  void _internal_set_num_hard_examples(int32_t value);
  public:

  // optional float iou_threshold = 2 [default = 0.7];
  bool has_iou_threshold() const;
  private:
  bool _internal_has_iou_threshold() const;
  public:
  void clear_iou_threshold();
  float iou_threshold() const;
  void set_iou_threshold(float value);
  private:
  float _internal_iou_threshold() const;
  void _internal_set_iou_threshold(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int loss_type_;
    int32_t max_negatives_per_positive_;
    int32_t min_negatives_per_image_;
    int32_t num_hard_examples_;
    float iou_threshold_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float positive_sample_fraction_;
  };
  union { Impl_ _impl_; };
  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::_internal_has_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Loss_EqualizationLoss::has_weight() const {
  return _internal_has_weight();
}
inline void Loss_EqualizationLoss::clear_weight() {
  _impl_.weight_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float Loss_EqualizationLoss::_internal_weight() const {
  return _impl_.weight_;
}
inline float Loss_EqualizationLoss::weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.EqualizationLoss.weight)
  return _internal_weight();
}
inline void Loss_EqualizationLoss::_internal_set_weight(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.weight_ = value;
}
inline void Loss_EqualizationLoss::set_weight(float value) {
  _internal_set_weight(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.EqualizationLoss.weight)
}

// repeated string exclude_prefixes = 2;
inline int Loss_EqualizationLoss::_internal_exclude_prefixes_size() const {
  return _impl_.exclude_prefixes_.size();
}
inline int Loss_EqualizationLoss::exclude_prefixes_size() const {
  return _internal_exclude_prefixes_size();
}
inline void Loss_EqualizationLoss::clear_exclude_prefixes() {
  _impl_.exclude_prefixes_.Clear();
}
inline std::string* Loss_EqualizationLoss::add_exclude_prefixes() {
  std::string* _s = _internal_add_exclude_prefixes();
  // @@protoc_insertion_point(field_add_mutable:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return _s;
}
inline const std::string& Loss_EqualizationLoss::_internal_exclude_prefixes(int index) const {
  return _impl_.exclude_prefixes_.Get(index);
}
inline const std::string& Loss_EqualizationLoss::exclude_prefixes(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return _internal_exclude_prefixes(index);
}
inline std::string* Loss_EqualizationLoss::mutable_exclude_prefixes(int index) {
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
  return _impl_.exclude_prefixes_.Mutable(index);
}
inline void Loss_EqualizationLoss::set_exclude_prefixes(int index, const std::string& value) {
  _impl_.exclude_prefixes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline void Loss_EqualizationLoss::set_exclude_prefixes(int index, std::string&& value) {
  _impl_.exclude_prefixes_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.EqualizationLoss.exclude_prefixes)
}
inline void Loss_EqualizationLoss::set_exclude_prefixes(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.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) {
  _impl_.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::_internal_add_exclude_prefixes() {
  return _impl_.exclude_prefixes_.Add();
}
inline void Loss_EqualizationLoss::add_exclude_prefixes(const std::string& value) {
  _impl_.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) {
  _impl_.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);
  _impl_.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) {
  _impl_.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 _impl_.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 &_impl_.exclude_prefixes_;
}

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

// Loss

// optional .object_detection.protos.LocalizationLoss localization_loss = 1;
inline bool Loss::_internal_has_localization_loss() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.localization_loss_ != nullptr);
  return value;
}
inline bool Loss::has_localization_loss() const {
  return _internal_has_localization_loss();
}
inline void Loss::clear_localization_loss() {
  if (_impl_.localization_loss_ != nullptr) _impl_.localization_loss_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::object_detection::protos::LocalizationLoss& Loss::_internal_localization_loss() const {
  const ::object_detection::protos::LocalizationLoss* p = _impl_.localization_loss_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::LocalizationLoss&>(
      ::object_detection::protos::_LocalizationLoss_default_instance_);
}
inline const ::object_detection::protos::LocalizationLoss& Loss::localization_loss() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.localization_loss)
  return _internal_localization_loss();
}
inline void Loss::unsafe_arena_set_allocated_localization_loss(
    ::object_detection::protos::LocalizationLoss* localization_loss) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.localization_loss_);
  }
  _impl_.localization_loss_ = localization_loss;
  if (localization_loss) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Loss.localization_loss)
}
inline ::object_detection::protos::LocalizationLoss* Loss::release_localization_loss() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::LocalizationLoss* temp = _impl_.localization_loss_;
  _impl_.localization_loss_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::object_detection::protos::LocalizationLoss* Loss::unsafe_arena_release_localization_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.localization_loss)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::object_detection::protos::LocalizationLoss* temp = _impl_.localization_loss_;
  _impl_.localization_loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::LocalizationLoss* Loss::_internal_mutable_localization_loss() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.localization_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::LocalizationLoss>(GetArenaForAllocation());
    _impl_.localization_loss_ = p;
  }
  return _impl_.localization_loss_;
}
inline ::object_detection::protos::LocalizationLoss* Loss::mutable_localization_loss() {
  ::object_detection::protos::LocalizationLoss* _msg = _internal_mutable_localization_loss();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.localization_loss)
  return _msg;
}
inline void Loss::set_allocated_localization_loss(::object_detection::protos::LocalizationLoss* localization_loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.localization_loss_;
  }
  if (localization_loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(localization_loss);
    if (message_arena != submessage_arena) {
      localization_loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, localization_loss, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.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::_internal_has_classification_loss() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.classification_loss_ != nullptr);
  return value;
}
inline bool Loss::has_classification_loss() const {
  return _internal_has_classification_loss();
}
inline void Loss::clear_classification_loss() {
  if (_impl_.classification_loss_ != nullptr) _impl_.classification_loss_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::object_detection::protos::ClassificationLoss& Loss::_internal_classification_loss() const {
  const ::object_detection::protos::ClassificationLoss* p = _impl_.classification_loss_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::ClassificationLoss&>(
      ::object_detection::protos::_ClassificationLoss_default_instance_);
}
inline const ::object_detection::protos::ClassificationLoss& Loss::classification_loss() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.classification_loss)
  return _internal_classification_loss();
}
inline void Loss::unsafe_arena_set_allocated_classification_loss(
    ::object_detection::protos::ClassificationLoss* classification_loss) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.classification_loss_);
  }
  _impl_.classification_loss_ = classification_loss;
  if (classification_loss) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Loss.classification_loss)
}
inline ::object_detection::protos::ClassificationLoss* Loss::release_classification_loss() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::ClassificationLoss* temp = _impl_.classification_loss_;
  _impl_.classification_loss_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::object_detection::protos::ClassificationLoss* Loss::unsafe_arena_release_classification_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.classification_loss)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::object_detection::protos::ClassificationLoss* temp = _impl_.classification_loss_;
  _impl_.classification_loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::ClassificationLoss* Loss::_internal_mutable_classification_loss() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.classification_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::ClassificationLoss>(GetArenaForAllocation());
    _impl_.classification_loss_ = p;
  }
  return _impl_.classification_loss_;
}
inline ::object_detection::protos::ClassificationLoss* Loss::mutable_classification_loss() {
  ::object_detection::protos::ClassificationLoss* _msg = _internal_mutable_classification_loss();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.classification_loss)
  return _msg;
}
inline void Loss::set_allocated_classification_loss(::object_detection::protos::ClassificationLoss* classification_loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.classification_loss_;
  }
  if (classification_loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(classification_loss);
    if (message_arena != submessage_arena) {
      classification_loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, classification_loss, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.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::_internal_has_hard_example_miner() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hard_example_miner_ != nullptr);
  return value;
}
inline bool Loss::has_hard_example_miner() const {
  return _internal_has_hard_example_miner();
}
inline void Loss::clear_hard_example_miner() {
  if (_impl_.hard_example_miner_ != nullptr) _impl_.hard_example_miner_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::object_detection::protos::HardExampleMiner& Loss::_internal_hard_example_miner() const {
  const ::object_detection::protos::HardExampleMiner* p = _impl_.hard_example_miner_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::HardExampleMiner&>(
      ::object_detection::protos::_HardExampleMiner_default_instance_);
}
inline const ::object_detection::protos::HardExampleMiner& Loss::hard_example_miner() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.hard_example_miner)
  return _internal_hard_example_miner();
}
inline void Loss::unsafe_arena_set_allocated_hard_example_miner(
    ::object_detection::protos::HardExampleMiner* hard_example_miner) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hard_example_miner_);
  }
  _impl_.hard_example_miner_ = hard_example_miner;
  if (hard_example_miner) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Loss.hard_example_miner)
}
inline ::object_detection::protos::HardExampleMiner* Loss::release_hard_example_miner() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::HardExampleMiner* temp = _impl_.hard_example_miner_;
  _impl_.hard_example_miner_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::object_detection::protos::HardExampleMiner* Loss::unsafe_arena_release_hard_example_miner() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.hard_example_miner)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::object_detection::protos::HardExampleMiner* temp = _impl_.hard_example_miner_;
  _impl_.hard_example_miner_ = nullptr;
  return temp;
}
inline ::object_detection::protos::HardExampleMiner* Loss::_internal_mutable_hard_example_miner() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.hard_example_miner_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::HardExampleMiner>(GetArenaForAllocation());
    _impl_.hard_example_miner_ = p;
  }
  return _impl_.hard_example_miner_;
}
inline ::object_detection::protos::HardExampleMiner* Loss::mutable_hard_example_miner() {
  ::object_detection::protos::HardExampleMiner* _msg = _internal_mutable_hard_example_miner();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.hard_example_miner)
  return _msg;
}
inline void Loss::set_allocated_hard_example_miner(::object_detection::protos::HardExampleMiner* hard_example_miner) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hard_example_miner_;
  }
  if (hard_example_miner) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hard_example_miner);
    if (message_arena != submessage_arena) {
      hard_example_miner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hard_example_miner, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.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::_internal_has_classification_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Loss::has_classification_weight() const {
  return _internal_has_classification_weight();
}
inline void Loss::clear_classification_weight() {
  _impl_.classification_weight_ = 1;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float Loss::_internal_classification_weight() const {
  return _impl_.classification_weight_;
}
inline float Loss::classification_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.classification_weight)
  return _internal_classification_weight();
}
inline void Loss::_internal_set_classification_weight(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.classification_weight_ = value;
}
inline void Loss::set_classification_weight(float value) {
  _internal_set_classification_weight(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.classification_weight)
}

// optional float localization_weight = 5 [default = 1];
inline bool Loss::_internal_has_localization_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Loss::has_localization_weight() const {
  return _internal_has_localization_weight();
}
inline void Loss::clear_localization_weight() {
  _impl_.localization_weight_ = 1;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline float Loss::_internal_localization_weight() const {
  return _impl_.localization_weight_;
}
inline float Loss::localization_weight() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.localization_weight)
  return _internal_localization_weight();
}
inline void Loss::_internal_set_localization_weight(float value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.localization_weight_ = value;
}
inline void Loss::set_localization_weight(float value) {
  _internal_set_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::_internal_has_random_example_sampler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.random_example_sampler_ != nullptr);
  return value;
}
inline bool Loss::has_random_example_sampler() const {
  return _internal_has_random_example_sampler();
}
inline void Loss::clear_random_example_sampler() {
  if (_impl_.random_example_sampler_ != nullptr) _impl_.random_example_sampler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::object_detection::protos::RandomExampleSampler& Loss::_internal_random_example_sampler() const {
  const ::object_detection::protos::RandomExampleSampler* p = _impl_.random_example_sampler_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::RandomExampleSampler&>(
      ::object_detection::protos::_RandomExampleSampler_default_instance_);
}
inline const ::object_detection::protos::RandomExampleSampler& Loss::random_example_sampler() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.random_example_sampler)
  return _internal_random_example_sampler();
}
inline void Loss::unsafe_arena_set_allocated_random_example_sampler(
    ::object_detection::protos::RandomExampleSampler* random_example_sampler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.random_example_sampler_);
  }
  _impl_.random_example_sampler_ = random_example_sampler;
  if (random_example_sampler) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Loss.random_example_sampler)
}
inline ::object_detection::protos::RandomExampleSampler* Loss::release_random_example_sampler() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::object_detection::protos::RandomExampleSampler* temp = _impl_.random_example_sampler_;
  _impl_.random_example_sampler_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::object_detection::protos::RandomExampleSampler* Loss::unsafe_arena_release_random_example_sampler() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.random_example_sampler)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::object_detection::protos::RandomExampleSampler* temp = _impl_.random_example_sampler_;
  _impl_.random_example_sampler_ = nullptr;
  return temp;
}
inline ::object_detection::protos::RandomExampleSampler* Loss::_internal_mutable_random_example_sampler() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.random_example_sampler_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::RandomExampleSampler>(GetArenaForAllocation());
    _impl_.random_example_sampler_ = p;
  }
  return _impl_.random_example_sampler_;
}
inline ::object_detection::protos::RandomExampleSampler* Loss::mutable_random_example_sampler() {
  ::object_detection::protos::RandomExampleSampler* _msg = _internal_mutable_random_example_sampler();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.random_example_sampler)
  return _msg;
}
inline void Loss::set_allocated_random_example_sampler(::object_detection::protos::RandomExampleSampler* random_example_sampler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.random_example_sampler_;
  }
  if (random_example_sampler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(random_example_sampler);
    if (message_arena != submessage_arena) {
      random_example_sampler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, random_example_sampler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.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::_internal_has_equalization_loss() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.equalization_loss_ != nullptr);
  return value;
}
inline bool Loss::has_equalization_loss() const {
  return _internal_has_equalization_loss();
}
inline void Loss::clear_equalization_loss() {
  if (_impl_.equalization_loss_ != nullptr) _impl_.equalization_loss_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::object_detection::protos::Loss_EqualizationLoss& Loss::_internal_equalization_loss() const {
  const ::object_detection::protos::Loss_EqualizationLoss* p = _impl_.equalization_loss_;
  return p != nullptr ? *p : reinterpret_cast<const ::object_detection::protos::Loss_EqualizationLoss&>(
      ::object_detection::protos::_Loss_EqualizationLoss_default_instance_);
}
inline const ::object_detection::protos::Loss_EqualizationLoss& Loss::equalization_loss() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.equalization_loss)
  return _internal_equalization_loss();
}
inline void Loss::unsafe_arena_set_allocated_equalization_loss(
    ::object_detection::protos::Loss_EqualizationLoss* equalization_loss) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.equalization_loss_);
  }
  _impl_.equalization_loss_ = equalization_loss;
  if (equalization_loss) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.Loss.equalization_loss)
}
inline ::object_detection::protos::Loss_EqualizationLoss* Loss::release_equalization_loss() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::object_detection::protos::Loss_EqualizationLoss* temp = _impl_.equalization_loss_;
  _impl_.equalization_loss_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::object_detection::protos::Loss_EqualizationLoss* Loss::unsafe_arena_release_equalization_loss() {
  // @@protoc_insertion_point(field_release:object_detection.protos.Loss.equalization_loss)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::object_detection::protos::Loss_EqualizationLoss* temp = _impl_.equalization_loss_;
  _impl_.equalization_loss_ = nullptr;
  return temp;
}
inline ::object_detection::protos::Loss_EqualizationLoss* Loss::_internal_mutable_equalization_loss() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.equalization_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::object_detection::protos::Loss_EqualizationLoss>(GetArenaForAllocation());
    _impl_.equalization_loss_ = p;
  }
  return _impl_.equalization_loss_;
}
inline ::object_detection::protos::Loss_EqualizationLoss* Loss::mutable_equalization_loss() {
  ::object_detection::protos::Loss_EqualizationLoss* _msg = _internal_mutable_equalization_loss();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.Loss.equalization_loss)
  return _msg;
}
inline void Loss::set_allocated_equalization_loss(::object_detection::protos::Loss_EqualizationLoss* equalization_loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.equalization_loss_;
  }
  if (equalization_loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(equalization_loss);
    if (message_arena != submessage_arena) {
      equalization_loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, equalization_loss, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.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::_internal_has_expected_loss_weights() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Loss::has_expected_loss_weights() const {
  return _internal_has_expected_loss_weights();
}
inline void Loss::clear_expected_loss_weights() {
  _impl_.expected_loss_weights_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::object_detection::protos::Loss_ExpectedLossWeights Loss::_internal_expected_loss_weights() const {
  return static_cast< ::object_detection::protos::Loss_ExpectedLossWeights >(_impl_.expected_loss_weights_);
}
inline ::object_detection::protos::Loss_ExpectedLossWeights Loss::expected_loss_weights() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.expected_loss_weights)
  return _internal_expected_loss_weights();
}
inline void Loss::_internal_set_expected_loss_weights(::object_detection::protos::Loss_ExpectedLossWeights value) {
  assert(::object_detection::protos::Loss_ExpectedLossWeights_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.expected_loss_weights_ = value;
}
inline void Loss::set_expected_loss_weights(::object_detection::protos::Loss_ExpectedLossWeights value) {
  _internal_set_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::_internal_has_min_num_negative_samples() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Loss::has_min_num_negative_samples() const {
  return _internal_has_min_num_negative_samples();
}
inline void Loss::clear_min_num_negative_samples() {
  _impl_.min_num_negative_samples_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float Loss::_internal_min_num_negative_samples() const {
  return _impl_.min_num_negative_samples_;
}
inline float Loss::min_num_negative_samples() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.min_num_negative_samples)
  return _internal_min_num_negative_samples();
}
inline void Loss::_internal_set_min_num_negative_samples(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.min_num_negative_samples_ = value;
}
inline void Loss::set_min_num_negative_samples(float value) {
  _internal_set_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::_internal_has_desired_negative_sampling_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Loss::has_desired_negative_sampling_ratio() const {
  return _internal_has_desired_negative_sampling_ratio();
}
inline void Loss::clear_desired_negative_sampling_ratio() {
  _impl_.desired_negative_sampling_ratio_ = 3;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float Loss::_internal_desired_negative_sampling_ratio() const {
  return _impl_.desired_negative_sampling_ratio_;
}
inline float Loss::desired_negative_sampling_ratio() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.Loss.desired_negative_sampling_ratio)
  return _internal_desired_negative_sampling_ratio();
}
inline void Loss::_internal_set_desired_negative_sampling_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.desired_negative_sampling_ratio_ = value;
}
inline void Loss::set_desired_negative_sampling_ratio(float value) {
  _internal_set_desired_negative_sampling_ratio(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.Loss.desired_negative_sampling_ratio)
}

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

// LocalizationLoss

// .object_detection.protos.WeightedL2LocalizationLoss weighted_l2 = 1;
inline bool LocalizationLoss::_internal_has_weighted_l2() const {
  return localization_loss_case() == kWeightedL2;
}
inline bool LocalizationLoss::has_weighted_l2() const {
  return _internal_has_weighted_l2();
}
inline void LocalizationLoss::set_has_weighted_l2() {
  _impl_._oneof_case_[0] = kWeightedL2;
}
inline void LocalizationLoss::clear_weighted_l2() {
  if (_internal_has_weighted_l2()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_weighted_l2()) {
    clear_has_localization_loss();
    ::object_detection::protos::WeightedL2LocalizationLoss* temp = _impl_.localization_loss_.weighted_l2_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.localization_loss_.weighted_l2_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedL2LocalizationLoss& LocalizationLoss::_internal_weighted_l2() const {
  return _internal_has_weighted_l2()
      ? *_impl_.localization_loss_.weighted_l2_
      : reinterpret_cast< ::object_detection::protos::WeightedL2LocalizationLoss&>(::object_detection::protos::_WeightedL2LocalizationLoss_default_instance_);
}
inline const ::object_detection::protos::WeightedL2LocalizationLoss& LocalizationLoss::weighted_l2() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.LocalizationLoss.weighted_l2)
  return _internal_weighted_l2();
}
inline ::object_detection::protos::WeightedL2LocalizationLoss* LocalizationLoss::unsafe_arena_release_weighted_l2() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.LocalizationLoss.weighted_l2)
  if (_internal_has_weighted_l2()) {
    clear_has_localization_loss();
    ::object_detection::protos::WeightedL2LocalizationLoss* temp = _impl_.localization_loss_.weighted_l2_;
    _impl_.localization_loss_.weighted_l2_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LocalizationLoss::unsafe_arena_set_allocated_weighted_l2(::object_detection::protos::WeightedL2LocalizationLoss* weighted_l2) {
  clear_localization_loss();
  if (weighted_l2) {
    set_has_weighted_l2();
    _impl_.localization_loss_.weighted_l2_ = weighted_l2;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.LocalizationLoss.weighted_l2)
}
inline ::object_detection::protos::WeightedL2LocalizationLoss* LocalizationLoss::_internal_mutable_weighted_l2() {
  if (!_internal_has_weighted_l2()) {
    clear_localization_loss();
    set_has_weighted_l2();
    _impl_.localization_loss_.weighted_l2_ = CreateMaybeMessage< ::object_detection::protos::WeightedL2LocalizationLoss >(GetArenaForAllocation());
  }
  return _impl_.localization_loss_.weighted_l2_;
}
inline ::object_detection::protos::WeightedL2LocalizationLoss* LocalizationLoss::mutable_weighted_l2() {
  ::object_detection::protos::WeightedL2LocalizationLoss* _msg = _internal_mutable_weighted_l2();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.LocalizationLoss.weighted_l2)
  return _msg;
}

// .object_detection.protos.WeightedSmoothL1LocalizationLoss weighted_smooth_l1 = 2;
inline bool LocalizationLoss::_internal_has_weighted_smooth_l1() const {
  return localization_loss_case() == kWeightedSmoothL1;
}
inline bool LocalizationLoss::has_weighted_smooth_l1() const {
  return _internal_has_weighted_smooth_l1();
}
inline void LocalizationLoss::set_has_weighted_smooth_l1() {
  _impl_._oneof_case_[0] = kWeightedSmoothL1;
}
inline void LocalizationLoss::clear_weighted_smooth_l1() {
  if (_internal_has_weighted_smooth_l1()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_weighted_smooth_l1()) {
    clear_has_localization_loss();
    ::object_detection::protos::WeightedSmoothL1LocalizationLoss* temp = _impl_.localization_loss_.weighted_smooth_l1_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.localization_loss_.weighted_smooth_l1_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSmoothL1LocalizationLoss& LocalizationLoss::_internal_weighted_smooth_l1() const {
  return _internal_has_weighted_smooth_l1()
      ? *_impl_.localization_loss_.weighted_smooth_l1_
      : reinterpret_cast< ::object_detection::protos::WeightedSmoothL1LocalizationLoss&>(::object_detection::protos::_WeightedSmoothL1LocalizationLoss_default_instance_);
}
inline const ::object_detection::protos::WeightedSmoothL1LocalizationLoss& LocalizationLoss::weighted_smooth_l1() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.LocalizationLoss.weighted_smooth_l1)
  return _internal_weighted_smooth_l1();
}
inline ::object_detection::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::unsafe_arena_release_weighted_smooth_l1() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.LocalizationLoss.weighted_smooth_l1)
  if (_internal_has_weighted_smooth_l1()) {
    clear_has_localization_loss();
    ::object_detection::protos::WeightedSmoothL1LocalizationLoss* temp = _impl_.localization_loss_.weighted_smooth_l1_;
    _impl_.localization_loss_.weighted_smooth_l1_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LocalizationLoss::unsafe_arena_set_allocated_weighted_smooth_l1(::object_detection::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1) {
  clear_localization_loss();
  if (weighted_smooth_l1) {
    set_has_weighted_smooth_l1();
    _impl_.localization_loss_.weighted_smooth_l1_ = weighted_smooth_l1;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.LocalizationLoss.weighted_smooth_l1)
}
inline ::object_detection::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::_internal_mutable_weighted_smooth_l1() {
  if (!_internal_has_weighted_smooth_l1()) {
    clear_localization_loss();
    set_has_weighted_smooth_l1();
    _impl_.localization_loss_.weighted_smooth_l1_ = CreateMaybeMessage< ::object_detection::protos::WeightedSmoothL1LocalizationLoss >(GetArenaForAllocation());
  }
  return _impl_.localization_loss_.weighted_smooth_l1_;
}
inline ::object_detection::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::mutable_weighted_smooth_l1() {
  ::object_detection::protos::WeightedSmoothL1LocalizationLoss* _msg = _internal_mutable_weighted_smooth_l1();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.LocalizationLoss.weighted_smooth_l1)
  return _msg;
}

// .object_detection.protos.WeightedIOULocalizationLoss weighted_iou = 3;
inline bool LocalizationLoss::_internal_has_weighted_iou() const {
  return localization_loss_case() == kWeightedIou;
}
inline bool LocalizationLoss::has_weighted_iou() const {
  return _internal_has_weighted_iou();
}
inline void LocalizationLoss::set_has_weighted_iou() {
  _impl_._oneof_case_[0] = kWeightedIou;
}
inline void LocalizationLoss::clear_weighted_iou() {
  if (_internal_has_weighted_iou()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_weighted_iou()) {
    clear_has_localization_loss();
    ::object_detection::protos::WeightedIOULocalizationLoss* temp = _impl_.localization_loss_.weighted_iou_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.localization_loss_.weighted_iou_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedIOULocalizationLoss& LocalizationLoss::_internal_weighted_iou() const {
  return _internal_has_weighted_iou()
      ? *_impl_.localization_loss_.weighted_iou_
      : reinterpret_cast< ::object_detection::protos::WeightedIOULocalizationLoss&>(::object_detection::protos::_WeightedIOULocalizationLoss_default_instance_);
}
inline const ::object_detection::protos::WeightedIOULocalizationLoss& LocalizationLoss::weighted_iou() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.LocalizationLoss.weighted_iou)
  return _internal_weighted_iou();
}
inline ::object_detection::protos::WeightedIOULocalizationLoss* LocalizationLoss::unsafe_arena_release_weighted_iou() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.LocalizationLoss.weighted_iou)
  if (_internal_has_weighted_iou()) {
    clear_has_localization_loss();
    ::object_detection::protos::WeightedIOULocalizationLoss* temp = _impl_.localization_loss_.weighted_iou_;
    _impl_.localization_loss_.weighted_iou_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LocalizationLoss::unsafe_arena_set_allocated_weighted_iou(::object_detection::protos::WeightedIOULocalizationLoss* weighted_iou) {
  clear_localization_loss();
  if (weighted_iou) {
    set_has_weighted_iou();
    _impl_.localization_loss_.weighted_iou_ = weighted_iou;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.LocalizationLoss.weighted_iou)
}
inline ::object_detection::protos::WeightedIOULocalizationLoss* LocalizationLoss::_internal_mutable_weighted_iou() {
  if (!_internal_has_weighted_iou()) {
    clear_localization_loss();
    set_has_weighted_iou();
    _impl_.localization_loss_.weighted_iou_ = CreateMaybeMessage< ::object_detection::protos::WeightedIOULocalizationLoss >(GetArenaForAllocation());
  }
  return _impl_.localization_loss_.weighted_iou_;
}
inline ::object_detection::protos::WeightedIOULocalizationLoss* LocalizationLoss::mutable_weighted_iou() {
  ::object_detection::protos::WeightedIOULocalizationLoss* _msg = _internal_mutable_weighted_iou();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.LocalizationLoss.weighted_iou)
  return _msg;
}

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

// WeightedL2LocalizationLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool WeightedL2LocalizationLoss::_internal_has_anchorwise_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WeightedL2LocalizationLoss::has_anchorwise_output() const {
  return _internal_has_anchorwise_output();
}
inline void WeightedL2LocalizationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedL2LocalizationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedL2LocalizationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedL2LocalizationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedL2LocalizationLoss::_internal_set_anchorwise_output(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.anchorwise_output_ = value;
}
inline void WeightedL2LocalizationLoss::set_anchorwise_output(bool value) {
  _internal_set_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::_internal_has_anchorwise_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WeightedSmoothL1LocalizationLoss::has_anchorwise_output() const {
  return _internal_has_anchorwise_output();
}
inline void WeightedSmoothL1LocalizationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedSmoothL1LocalizationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedSmoothL1LocalizationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSmoothL1LocalizationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedSmoothL1LocalizationLoss::_internal_set_anchorwise_output(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.anchorwise_output_ = value;
}
inline void WeightedSmoothL1LocalizationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSmoothL1LocalizationLoss.anchorwise_output)
}

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

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

// WeightedIOULocalizationLoss

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

// ClassificationLoss

// .object_detection.protos.WeightedSigmoidClassificationLoss weighted_sigmoid = 1;
inline bool ClassificationLoss::_internal_has_weighted_sigmoid() const {
  return classification_loss_case() == kWeightedSigmoid;
}
inline bool ClassificationLoss::has_weighted_sigmoid() const {
  return _internal_has_weighted_sigmoid();
}
inline void ClassificationLoss::set_has_weighted_sigmoid() {
  _impl_._oneof_case_[0] = kWeightedSigmoid;
}
inline void ClassificationLoss::clear_weighted_sigmoid() {
  if (_internal_has_weighted_sigmoid()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_weighted_sigmoid()) {
    clear_has_classification_loss();
    ::object_detection::protos::WeightedSigmoidClassificationLoss* temp = _impl_.classification_loss_.weighted_sigmoid_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.classification_loss_.weighted_sigmoid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSigmoidClassificationLoss& ClassificationLoss::_internal_weighted_sigmoid() const {
  return _internal_has_weighted_sigmoid()
      ? *_impl_.classification_loss_.weighted_sigmoid_
      : reinterpret_cast< ::object_detection::protos::WeightedSigmoidClassificationLoss&>(::object_detection::protos::_WeightedSigmoidClassificationLoss_default_instance_);
}
inline const ::object_detection::protos::WeightedSigmoidClassificationLoss& ClassificationLoss::weighted_sigmoid() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_sigmoid)
  return _internal_weighted_sigmoid();
}
inline ::object_detection::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::unsafe_arena_release_weighted_sigmoid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.ClassificationLoss.weighted_sigmoid)
  if (_internal_has_weighted_sigmoid()) {
    clear_has_classification_loss();
    ::object_detection::protos::WeightedSigmoidClassificationLoss* temp = _impl_.classification_loss_.weighted_sigmoid_;
    _impl_.classification_loss_.weighted_sigmoid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClassificationLoss::unsafe_arena_set_allocated_weighted_sigmoid(::object_detection::protos::WeightedSigmoidClassificationLoss* weighted_sigmoid) {
  clear_classification_loss();
  if (weighted_sigmoid) {
    set_has_weighted_sigmoid();
    _impl_.classification_loss_.weighted_sigmoid_ = weighted_sigmoid;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.ClassificationLoss.weighted_sigmoid)
}
inline ::object_detection::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::_internal_mutable_weighted_sigmoid() {
  if (!_internal_has_weighted_sigmoid()) {
    clear_classification_loss();
    set_has_weighted_sigmoid();
    _impl_.classification_loss_.weighted_sigmoid_ = CreateMaybeMessage< ::object_detection::protos::WeightedSigmoidClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_sigmoid_;
}
inline ::object_detection::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::mutable_weighted_sigmoid() {
  ::object_detection::protos::WeightedSigmoidClassificationLoss* _msg = _internal_mutable_weighted_sigmoid();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_sigmoid)
  return _msg;
}

// .object_detection.protos.WeightedSoftmaxClassificationLoss weighted_softmax = 2;
inline bool ClassificationLoss::_internal_has_weighted_softmax() const {
  return classification_loss_case() == kWeightedSoftmax;
}
inline bool ClassificationLoss::has_weighted_softmax() const {
  return _internal_has_weighted_softmax();
}
inline void ClassificationLoss::set_has_weighted_softmax() {
  _impl_._oneof_case_[0] = kWeightedSoftmax;
}
inline void ClassificationLoss::clear_weighted_softmax() {
  if (_internal_has_weighted_softmax()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_weighted_softmax()) {
    clear_has_classification_loss();
    ::object_detection::protos::WeightedSoftmaxClassificationLoss* temp = _impl_.classification_loss_.weighted_softmax_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.classification_loss_.weighted_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSoftmaxClassificationLoss& ClassificationLoss::_internal_weighted_softmax() const {
  return _internal_has_weighted_softmax()
      ? *_impl_.classification_loss_.weighted_softmax_
      : reinterpret_cast< ::object_detection::protos::WeightedSoftmaxClassificationLoss&>(::object_detection::protos::_WeightedSoftmaxClassificationLoss_default_instance_);
}
inline const ::object_detection::protos::WeightedSoftmaxClassificationLoss& ClassificationLoss::weighted_softmax() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_softmax)
  return _internal_weighted_softmax();
}
inline ::object_detection::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::unsafe_arena_release_weighted_softmax() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.ClassificationLoss.weighted_softmax)
  if (_internal_has_weighted_softmax()) {
    clear_has_classification_loss();
    ::object_detection::protos::WeightedSoftmaxClassificationLoss* temp = _impl_.classification_loss_.weighted_softmax_;
    _impl_.classification_loss_.weighted_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClassificationLoss::unsafe_arena_set_allocated_weighted_softmax(::object_detection::protos::WeightedSoftmaxClassificationLoss* weighted_softmax) {
  clear_classification_loss();
  if (weighted_softmax) {
    set_has_weighted_softmax();
    _impl_.classification_loss_.weighted_softmax_ = weighted_softmax;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.ClassificationLoss.weighted_softmax)
}
inline ::object_detection::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::_internal_mutable_weighted_softmax() {
  if (!_internal_has_weighted_softmax()) {
    clear_classification_loss();
    set_has_weighted_softmax();
    _impl_.classification_loss_.weighted_softmax_ = CreateMaybeMessage< ::object_detection::protos::WeightedSoftmaxClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_softmax_;
}
inline ::object_detection::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::mutable_weighted_softmax() {
  ::object_detection::protos::WeightedSoftmaxClassificationLoss* _msg = _internal_mutable_weighted_softmax();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_softmax)
  return _msg;
}

// .object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss weighted_logits_softmax = 5;
inline bool ClassificationLoss::_internal_has_weighted_logits_softmax() const {
  return classification_loss_case() == kWeightedLogitsSoftmax;
}
inline bool ClassificationLoss::has_weighted_logits_softmax() const {
  return _internal_has_weighted_logits_softmax();
}
inline void ClassificationLoss::set_has_weighted_logits_softmax() {
  _impl_._oneof_case_[0] = kWeightedLogitsSoftmax;
}
inline void ClassificationLoss::clear_weighted_logits_softmax() {
  if (_internal_has_weighted_logits_softmax()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_weighted_logits_softmax()) {
    clear_has_classification_loss();
    ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* temp = _impl_.classification_loss_.weighted_logits_softmax_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.classification_loss_.weighted_logits_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss& ClassificationLoss::_internal_weighted_logits_softmax() const {
  return _internal_has_weighted_logits_softmax()
      ? *_impl_.classification_loss_.weighted_logits_softmax_
      : reinterpret_cast< ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss&>(::object_detection::protos::_WeightedSoftmaxClassificationAgainstLogitsLoss_default_instance_);
}
inline const ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss& ClassificationLoss::weighted_logits_softmax() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_logits_softmax)
  return _internal_weighted_logits_softmax();
}
inline ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* ClassificationLoss::unsafe_arena_release_weighted_logits_softmax() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.ClassificationLoss.weighted_logits_softmax)
  if (_internal_has_weighted_logits_softmax()) {
    clear_has_classification_loss();
    ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* temp = _impl_.classification_loss_.weighted_logits_softmax_;
    _impl_.classification_loss_.weighted_logits_softmax_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClassificationLoss::unsafe_arena_set_allocated_weighted_logits_softmax(::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* weighted_logits_softmax) {
  clear_classification_loss();
  if (weighted_logits_softmax) {
    set_has_weighted_logits_softmax();
    _impl_.classification_loss_.weighted_logits_softmax_ = weighted_logits_softmax;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.ClassificationLoss.weighted_logits_softmax)
}
inline ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* ClassificationLoss::_internal_mutable_weighted_logits_softmax() {
  if (!_internal_has_weighted_logits_softmax()) {
    clear_classification_loss();
    set_has_weighted_logits_softmax();
    _impl_.classification_loss_.weighted_logits_softmax_ = CreateMaybeMessage< ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_logits_softmax_;
}
inline ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* ClassificationLoss::mutable_weighted_logits_softmax() {
  ::object_detection::protos::WeightedSoftmaxClassificationAgainstLogitsLoss* _msg = _internal_mutable_weighted_logits_softmax();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_logits_softmax)
  return _msg;
}

// .object_detection.protos.BootstrappedSigmoidClassificationLoss bootstrapped_sigmoid = 3;
inline bool ClassificationLoss::_internal_has_bootstrapped_sigmoid() const {
  return classification_loss_case() == kBootstrappedSigmoid;
}
inline bool ClassificationLoss::has_bootstrapped_sigmoid() const {
  return _internal_has_bootstrapped_sigmoid();
}
inline void ClassificationLoss::set_has_bootstrapped_sigmoid() {
  _impl_._oneof_case_[0] = kBootstrappedSigmoid;
}
inline void ClassificationLoss::clear_bootstrapped_sigmoid() {
  if (_internal_has_bootstrapped_sigmoid()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_bootstrapped_sigmoid()) {
    clear_has_classification_loss();
    ::object_detection::protos::BootstrappedSigmoidClassificationLoss* temp = _impl_.classification_loss_.bootstrapped_sigmoid_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.classification_loss_.bootstrapped_sigmoid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::BootstrappedSigmoidClassificationLoss& ClassificationLoss::_internal_bootstrapped_sigmoid() const {
  return _internal_has_bootstrapped_sigmoid()
      ? *_impl_.classification_loss_.bootstrapped_sigmoid_
      : reinterpret_cast< ::object_detection::protos::BootstrappedSigmoidClassificationLoss&>(::object_detection::protos::_BootstrappedSigmoidClassificationLoss_default_instance_);
}
inline const ::object_detection::protos::BootstrappedSigmoidClassificationLoss& ClassificationLoss::bootstrapped_sigmoid() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.bootstrapped_sigmoid)
  return _internal_bootstrapped_sigmoid();
}
inline ::object_detection::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::unsafe_arena_release_bootstrapped_sigmoid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.ClassificationLoss.bootstrapped_sigmoid)
  if (_internal_has_bootstrapped_sigmoid()) {
    clear_has_classification_loss();
    ::object_detection::protos::BootstrappedSigmoidClassificationLoss* temp = _impl_.classification_loss_.bootstrapped_sigmoid_;
    _impl_.classification_loss_.bootstrapped_sigmoid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClassificationLoss::unsafe_arena_set_allocated_bootstrapped_sigmoid(::object_detection::protos::BootstrappedSigmoidClassificationLoss* bootstrapped_sigmoid) {
  clear_classification_loss();
  if (bootstrapped_sigmoid) {
    set_has_bootstrapped_sigmoid();
    _impl_.classification_loss_.bootstrapped_sigmoid_ = bootstrapped_sigmoid;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.ClassificationLoss.bootstrapped_sigmoid)
}
inline ::object_detection::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::_internal_mutable_bootstrapped_sigmoid() {
  if (!_internal_has_bootstrapped_sigmoid()) {
    clear_classification_loss();
    set_has_bootstrapped_sigmoid();
    _impl_.classification_loss_.bootstrapped_sigmoid_ = CreateMaybeMessage< ::object_detection::protos::BootstrappedSigmoidClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.bootstrapped_sigmoid_;
}
inline ::object_detection::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::mutable_bootstrapped_sigmoid() {
  ::object_detection::protos::BootstrappedSigmoidClassificationLoss* _msg = _internal_mutable_bootstrapped_sigmoid();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.bootstrapped_sigmoid)
  return _msg;
}

// .object_detection.protos.SigmoidFocalClassificationLoss weighted_sigmoid_focal = 4;
inline bool ClassificationLoss::_internal_has_weighted_sigmoid_focal() const {
  return classification_loss_case() == kWeightedSigmoidFocal;
}
inline bool ClassificationLoss::has_weighted_sigmoid_focal() const {
  return _internal_has_weighted_sigmoid_focal();
}
inline void ClassificationLoss::set_has_weighted_sigmoid_focal() {
  _impl_._oneof_case_[0] = kWeightedSigmoidFocal;
}
inline void ClassificationLoss::clear_weighted_sigmoid_focal() {
  if (_internal_has_weighted_sigmoid_focal()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.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 (_internal_has_weighted_sigmoid_focal()) {
    clear_has_classification_loss();
    ::object_detection::protos::SigmoidFocalClassificationLoss* temp = _impl_.classification_loss_.weighted_sigmoid_focal_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.classification_loss_.weighted_sigmoid_focal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::SigmoidFocalClassificationLoss& ClassificationLoss::_internal_weighted_sigmoid_focal() const {
  return _internal_has_weighted_sigmoid_focal()
      ? *_impl_.classification_loss_.weighted_sigmoid_focal_
      : reinterpret_cast< ::object_detection::protos::SigmoidFocalClassificationLoss&>(::object_detection::protos::_SigmoidFocalClassificationLoss_default_instance_);
}
inline const ::object_detection::protos::SigmoidFocalClassificationLoss& ClassificationLoss::weighted_sigmoid_focal() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.ClassificationLoss.weighted_sigmoid_focal)
  return _internal_weighted_sigmoid_focal();
}
inline ::object_detection::protos::SigmoidFocalClassificationLoss* ClassificationLoss::unsafe_arena_release_weighted_sigmoid_focal() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.ClassificationLoss.weighted_sigmoid_focal)
  if (_internal_has_weighted_sigmoid_focal()) {
    clear_has_classification_loss();
    ::object_detection::protos::SigmoidFocalClassificationLoss* temp = _impl_.classification_loss_.weighted_sigmoid_focal_;
    _impl_.classification_loss_.weighted_sigmoid_focal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClassificationLoss::unsafe_arena_set_allocated_weighted_sigmoid_focal(::object_detection::protos::SigmoidFocalClassificationLoss* weighted_sigmoid_focal) {
  clear_classification_loss();
  if (weighted_sigmoid_focal) {
    set_has_weighted_sigmoid_focal();
    _impl_.classification_loss_.weighted_sigmoid_focal_ = weighted_sigmoid_focal;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.ClassificationLoss.weighted_sigmoid_focal)
}
inline ::object_detection::protos::SigmoidFocalClassificationLoss* ClassificationLoss::_internal_mutable_weighted_sigmoid_focal() {
  if (!_internal_has_weighted_sigmoid_focal()) {
    clear_classification_loss();
    set_has_weighted_sigmoid_focal();
    _impl_.classification_loss_.weighted_sigmoid_focal_ = CreateMaybeMessage< ::object_detection::protos::SigmoidFocalClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_sigmoid_focal_;
}
inline ::object_detection::protos::SigmoidFocalClassificationLoss* ClassificationLoss::mutable_weighted_sigmoid_focal() {
  ::object_detection::protos::SigmoidFocalClassificationLoss* _msg = _internal_mutable_weighted_sigmoid_focal();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.ClassificationLoss.weighted_sigmoid_focal)
  return _msg;
}

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

// WeightedSigmoidClassificationLoss

// optional bool anchorwise_output = 1 [default = false];
inline bool WeightedSigmoidClassificationLoss::_internal_has_anchorwise_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WeightedSigmoidClassificationLoss::has_anchorwise_output() const {
  return _internal_has_anchorwise_output();
}
inline void WeightedSigmoidClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedSigmoidClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedSigmoidClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSigmoidClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedSigmoidClassificationLoss::_internal_set_anchorwise_output(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.anchorwise_output_ = value;
}
inline void WeightedSigmoidClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_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::_internal_has_anchorwise_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SigmoidFocalClassificationLoss::has_anchorwise_output() const {
  return _internal_has_anchorwise_output();
}
inline void SigmoidFocalClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SigmoidFocalClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool SigmoidFocalClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.SigmoidFocalClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void SigmoidFocalClassificationLoss::_internal_set_anchorwise_output(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.anchorwise_output_ = value;
}
inline void SigmoidFocalClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.SigmoidFocalClassificationLoss.anchorwise_output)
}

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

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

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

// WeightedSoftmaxClassificationLoss

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

// optional float logit_scale = 2 [default = 1];
inline bool WeightedSoftmaxClassificationLoss::_internal_has_logit_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool WeightedSoftmaxClassificationLoss::has_logit_scale() const {
  return _internal_has_logit_scale();
}
inline void WeightedSoftmaxClassificationLoss::clear_logit_scale() {
  _impl_.logit_scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float WeightedSoftmaxClassificationLoss::_internal_logit_scale() const {
  return _impl_.logit_scale_;
}
inline float WeightedSoftmaxClassificationLoss::logit_scale() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSoftmaxClassificationLoss.logit_scale)
  return _internal_logit_scale();
}
inline void WeightedSoftmaxClassificationLoss::_internal_set_logit_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.logit_scale_ = value;
}
inline void WeightedSoftmaxClassificationLoss::set_logit_scale(float value) {
  _internal_set_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::_internal_has_anchorwise_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WeightedSoftmaxClassificationAgainstLogitsLoss::has_anchorwise_output() const {
  return _internal_has_anchorwise_output();
}
inline void WeightedSoftmaxClassificationAgainstLogitsLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool WeightedSoftmaxClassificationAgainstLogitsLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedSoftmaxClassificationAgainstLogitsLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedSoftmaxClassificationAgainstLogitsLoss::_internal_set_anchorwise_output(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.anchorwise_output_ = value;
}
inline void WeightedSoftmaxClassificationAgainstLogitsLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.WeightedSoftmaxClassificationAgainstLogitsLoss.anchorwise_output)
}

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

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

// BootstrappedSigmoidClassificationLoss

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

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

// optional bool anchorwise_output = 3 [default = false];
inline bool BootstrappedSigmoidClassificationLoss::_internal_has_anchorwise_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BootstrappedSigmoidClassificationLoss::has_anchorwise_output() const {
  return _internal_has_anchorwise_output();
}
inline void BootstrappedSigmoidClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool BootstrappedSigmoidClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool BootstrappedSigmoidClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.BootstrappedSigmoidClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void BootstrappedSigmoidClassificationLoss::_internal_set_anchorwise_output(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.anchorwise_output_ = value;
}
inline void BootstrappedSigmoidClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_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::_internal_has_num_hard_examples() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool HardExampleMiner::has_num_hard_examples() const {
  return _internal_has_num_hard_examples();
}
inline void HardExampleMiner::clear_num_hard_examples() {
  _impl_.num_hard_examples_ = 64;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t HardExampleMiner::_internal_num_hard_examples() const {
  return _impl_.num_hard_examples_;
}
inline int32_t HardExampleMiner::num_hard_examples() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.num_hard_examples)
  return _internal_num_hard_examples();
}
inline void HardExampleMiner::_internal_set_num_hard_examples(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.num_hard_examples_ = value;
}
inline void HardExampleMiner::set_num_hard_examples(int32_t value) {
  _internal_set_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::_internal_has_iou_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool HardExampleMiner::has_iou_threshold() const {
  return _internal_has_iou_threshold();
}
inline void HardExampleMiner::clear_iou_threshold() {
  _impl_.iou_threshold_ = 0.7f;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float HardExampleMiner::_internal_iou_threshold() const {
  return _impl_.iou_threshold_;
}
inline float HardExampleMiner::iou_threshold() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.iou_threshold)
  return _internal_iou_threshold();
}
inline void HardExampleMiner::_internal_set_iou_threshold(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.iou_threshold_ = value;
}
inline void HardExampleMiner::set_iou_threshold(float value) {
  _internal_set_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::_internal_has_loss_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HardExampleMiner::has_loss_type() const {
  return _internal_has_loss_type();
}
inline void HardExampleMiner::clear_loss_type() {
  _impl_.loss_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::object_detection::protos::HardExampleMiner_LossType HardExampleMiner::_internal_loss_type() const {
  return static_cast< ::object_detection::protos::HardExampleMiner_LossType >(_impl_.loss_type_);
}
inline ::object_detection::protos::HardExampleMiner_LossType HardExampleMiner::loss_type() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.loss_type)
  return _internal_loss_type();
}
inline void HardExampleMiner::_internal_set_loss_type(::object_detection::protos::HardExampleMiner_LossType value) {
  assert(::object_detection::protos::HardExampleMiner_LossType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.loss_type_ = value;
}
inline void HardExampleMiner::set_loss_type(::object_detection::protos::HardExampleMiner_LossType value) {
  _internal_set_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::_internal_has_max_negatives_per_positive() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HardExampleMiner::has_max_negatives_per_positive() const {
  return _internal_has_max_negatives_per_positive();
}
inline void HardExampleMiner::clear_max_negatives_per_positive() {
  _impl_.max_negatives_per_positive_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t HardExampleMiner::_internal_max_negatives_per_positive() const {
  return _impl_.max_negatives_per_positive_;
}
inline int32_t HardExampleMiner::max_negatives_per_positive() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.max_negatives_per_positive)
  return _internal_max_negatives_per_positive();
}
inline void HardExampleMiner::_internal_set_max_negatives_per_positive(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.max_negatives_per_positive_ = value;
}
inline void HardExampleMiner::set_max_negatives_per_positive(int32_t value) {
  _internal_set_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::_internal_has_min_negatives_per_image() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HardExampleMiner::has_min_negatives_per_image() const {
  return _internal_has_min_negatives_per_image();
}
inline void HardExampleMiner::clear_min_negatives_per_image() {
  _impl_.min_negatives_per_image_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t HardExampleMiner::_internal_min_negatives_per_image() const {
  return _impl_.min_negatives_per_image_;
}
inline int32_t HardExampleMiner::min_negatives_per_image() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.HardExampleMiner.min_negatives_per_image)
  return _internal_min_negatives_per_image();
}
inline void HardExampleMiner::_internal_set_min_negatives_per_image(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.min_negatives_per_image_ = value;
}
inline void HardExampleMiner::set_min_negatives_per_image(int32_t value) {
  _internal_set_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::_internal_has_positive_sample_fraction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RandomExampleSampler::has_positive_sample_fraction() const {
  return _internal_has_positive_sample_fraction();
}
inline void RandomExampleSampler::clear_positive_sample_fraction() {
  _impl_.positive_sample_fraction_ = 0.01f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float RandomExampleSampler::_internal_positive_sample_fraction() const {
  return _impl_.positive_sample_fraction_;
}
inline float RandomExampleSampler::positive_sample_fraction() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.RandomExampleSampler.positive_sample_fraction)
  return _internal_positive_sample_fraction();
}
inline void RandomExampleSampler::_internal_set_positive_sample_fraction(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.positive_sample_fraction_ = value;
}
inline void RandomExampleSampler::set_positive_sample_fraction(float value) {
  _internal_set_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
