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

#ifndef GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2flosses_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_second_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_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_second_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_second_2fprotos_2flosses_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_second_2fprotos_2flosses_2eproto;
namespace second {
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 SigmoidFocalClassificationLoss;
struct SigmoidFocalClassificationLossDefaultTypeInternal;
extern SigmoidFocalClassificationLossDefaultTypeInternal _SigmoidFocalClassificationLoss_default_instance_;
class SoftmaxFocalClassificationLoss;
struct SoftmaxFocalClassificationLossDefaultTypeInternal;
extern SoftmaxFocalClassificationLossDefaultTypeInternal _SoftmaxFocalClassificationLoss_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 WeightedSoftmaxClassificationLoss;
struct WeightedSoftmaxClassificationLossDefaultTypeInternal;
extern WeightedSoftmaxClassificationLossDefaultTypeInternal _WeightedSoftmaxClassificationLoss_default_instance_;
}  // namespace protos
}  // namespace second
PROTOBUF_NAMESPACE_OPEN
template<> ::second::protos::BootstrappedSigmoidClassificationLoss* Arena::CreateMaybeMessage<::second::protos::BootstrappedSigmoidClassificationLoss>(Arena*);
template<> ::second::protos::ClassificationLoss* Arena::CreateMaybeMessage<::second::protos::ClassificationLoss>(Arena*);
template<> ::second::protos::HardExampleMiner* Arena::CreateMaybeMessage<::second::protos::HardExampleMiner>(Arena*);
template<> ::second::protos::LocalizationLoss* Arena::CreateMaybeMessage<::second::protos::LocalizationLoss>(Arena*);
template<> ::second::protos::Loss* Arena::CreateMaybeMessage<::second::protos::Loss>(Arena*);
template<> ::second::protos::SigmoidFocalClassificationLoss* Arena::CreateMaybeMessage<::second::protos::SigmoidFocalClassificationLoss>(Arena*);
template<> ::second::protos::SoftmaxFocalClassificationLoss* Arena::CreateMaybeMessage<::second::protos::SoftmaxFocalClassificationLoss>(Arena*);
template<> ::second::protos::WeightedL2LocalizationLoss* Arena::CreateMaybeMessage<::second::protos::WeightedL2LocalizationLoss>(Arena*);
template<> ::second::protos::WeightedSigmoidClassificationLoss* Arena::CreateMaybeMessage<::second::protos::WeightedSigmoidClassificationLoss>(Arena*);
template<> ::second::protos::WeightedSmoothL1LocalizationLoss* Arena::CreateMaybeMessage<::second::protos::WeightedSmoothL1LocalizationLoss>(Arena*);
template<> ::second::protos::WeightedSoftmaxClassificationLoss* Arena::CreateMaybeMessage<::second::protos::WeightedSoftmaxClassificationLoss>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace second {
namespace protos {

enum HardExampleMiner_LossType : int {
  HardExampleMiner_LossType_BOTH = 0,
  HardExampleMiner_LossType_CLASSIFICATION = 1,
  HardExampleMiner_LossType_LOCALIZATION = 2,
  HardExampleMiner_LossType_HardExampleMiner_LossType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  HardExampleMiner_LossType_HardExampleMiner_LossType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
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 final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    0;

  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 "second.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 ----------------------------------------------------

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

  enum : int {
    kLocalizationLossFieldNumber = 1,
    kClassificationLossFieldNumber = 2,
    kHardExampleMinerFieldNumber = 3,
    kClassificationWeightFieldNumber = 4,
    kLocalizationWeightFieldNumber = 5,
  };
  // .second.protos.LocalizationLoss localization_loss = 1;
  bool has_localization_loss() const;
  private:
  bool _internal_has_localization_loss() const;
  public:
  void clear_localization_loss();
  const ::second::protos::LocalizationLoss& localization_loss() const;
  PROTOBUF_NODISCARD ::second::protos::LocalizationLoss* release_localization_loss();
  ::second::protos::LocalizationLoss* mutable_localization_loss();
  void set_allocated_localization_loss(::second::protos::LocalizationLoss* localization_loss);
  private:
  const ::second::protos::LocalizationLoss& _internal_localization_loss() const;
  ::second::protos::LocalizationLoss* _internal_mutable_localization_loss();
  public:
  void unsafe_arena_set_allocated_localization_loss(
      ::second::protos::LocalizationLoss* localization_loss);
  ::second::protos::LocalizationLoss* unsafe_arena_release_localization_loss();

  // .second.protos.ClassificationLoss classification_loss = 2;
  bool has_classification_loss() const;
  private:
  bool _internal_has_classification_loss() const;
  public:
  void clear_classification_loss();
  const ::second::protos::ClassificationLoss& classification_loss() const;
  PROTOBUF_NODISCARD ::second::protos::ClassificationLoss* release_classification_loss();
  ::second::protos::ClassificationLoss* mutable_classification_loss();
  void set_allocated_classification_loss(::second::protos::ClassificationLoss* classification_loss);
  private:
  const ::second::protos::ClassificationLoss& _internal_classification_loss() const;
  ::second::protos::ClassificationLoss* _internal_mutable_classification_loss();
  public:
  void unsafe_arena_set_allocated_classification_loss(
      ::second::protos::ClassificationLoss* classification_loss);
  ::second::protos::ClassificationLoss* unsafe_arena_release_classification_loss();

  // .second.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 ::second::protos::HardExampleMiner& hard_example_miner() const;
  PROTOBUF_NODISCARD ::second::protos::HardExampleMiner* release_hard_example_miner();
  ::second::protos::HardExampleMiner* mutable_hard_example_miner();
  void set_allocated_hard_example_miner(::second::protos::HardExampleMiner* hard_example_miner);
  private:
  const ::second::protos::HardExampleMiner& _internal_hard_example_miner() const;
  ::second::protos::HardExampleMiner* _internal_mutable_hard_example_miner();
  public:
  void unsafe_arena_set_allocated_hard_example_miner(
      ::second::protos::HardExampleMiner* hard_example_miner);
  ::second::protos::HardExampleMiner* unsafe_arena_release_hard_example_miner();

  // float classification_weight = 4;
  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:

  // float localization_weight = 5;
  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:second.protos.Loss)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::second::protos::LocalizationLoss* localization_loss_;
    ::second::protos::ClassificationLoss* classification_loss_;
    ::second::protos::HardExampleMiner* hard_example_miner_;
    float classification_weight_;
    float localization_weight_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

class LocalizationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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,
    LOCALIZATION_LOSS_NOT_SET = 0,
  };

  static inline const LocalizationLoss* internal_default_instance() {
    return reinterpret_cast<const LocalizationLoss*>(
               &_LocalizationLoss_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  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 "second.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 {
    kEncodeRadErrorBySinFieldNumber = 3,
    kWeightedL2FieldNumber = 1,
    kWeightedSmoothL1FieldNumber = 2,
  };
  // bool encode_rad_error_by_sin = 3;
  void clear_encode_rad_error_by_sin();
  bool encode_rad_error_by_sin() const;
  void set_encode_rad_error_by_sin(bool value);
  private:
  bool _internal_encode_rad_error_by_sin() const;
  void _internal_set_encode_rad_error_by_sin(bool value);
  public:

  // .second.protos.WeightedL2LocalizationLoss weighted_l2 = 1;
  bool has_weighted_l2() const;
  private:
  bool _internal_has_weighted_l2() const;
  public:
  void clear_weighted_l2();
  const ::second::protos::WeightedL2LocalizationLoss& weighted_l2() const;
  PROTOBUF_NODISCARD ::second::protos::WeightedL2LocalizationLoss* release_weighted_l2();
  ::second::protos::WeightedL2LocalizationLoss* mutable_weighted_l2();
  void set_allocated_weighted_l2(::second::protos::WeightedL2LocalizationLoss* weighted_l2);
  private:
  const ::second::protos::WeightedL2LocalizationLoss& _internal_weighted_l2() const;
  ::second::protos::WeightedL2LocalizationLoss* _internal_mutable_weighted_l2();
  public:
  void unsafe_arena_set_allocated_weighted_l2(
      ::second::protos::WeightedL2LocalizationLoss* weighted_l2);
  ::second::protos::WeightedL2LocalizationLoss* unsafe_arena_release_weighted_l2();

  // .second.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 ::second::protos::WeightedSmoothL1LocalizationLoss& weighted_smooth_l1() const;
  PROTOBUF_NODISCARD ::second::protos::WeightedSmoothL1LocalizationLoss* release_weighted_smooth_l1();
  ::second::protos::WeightedSmoothL1LocalizationLoss* mutable_weighted_smooth_l1();
  void set_allocated_weighted_smooth_l1(::second::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1);
  private:
  const ::second::protos::WeightedSmoothL1LocalizationLoss& _internal_weighted_smooth_l1() const;
  ::second::protos::WeightedSmoothL1LocalizationLoss* _internal_mutable_weighted_smooth_l1();
  public:
  void unsafe_arena_set_allocated_weighted_smooth_l1(
      ::second::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1);
  ::second::protos::WeightedSmoothL1LocalizationLoss* unsafe_arena_release_weighted_smooth_l1();

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

  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_ {
    bool encode_rad_error_by_sin_;
    union LocalizationLossUnion {
      constexpr LocalizationLossUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::second::protos::WeightedL2LocalizationLoss* weighted_l2_;
      ::second::protos::WeightedSmoothL1LocalizationLoss* weighted_smooth_l1_;
    } localization_loss_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

class WeightedL2LocalizationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    2;

  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 "second.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 {
    kCodeWeightFieldNumber = 2,
    kAnchorwiseOutputFieldNumber = 1,
  };
  // repeated float code_weight = 2;
  int code_weight_size() const;
  private:
  int _internal_code_weight_size() const;
  public:
  void clear_code_weight();
  private:
  float _internal_code_weight(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_code_weight() const;
  void _internal_add_code_weight(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_code_weight();
  public:
  float code_weight(int index) const;
  void set_code_weight(int index, float value);
  void add_code_weight(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      code_weight() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_code_weight();

  // bool anchorwise_output = 1;
  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:second.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::RepeatedField< float > code_weight_;
    bool anchorwise_output_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

class WeightedSmoothL1LocalizationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    3;

  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 "second.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 {
    kCodeWeightFieldNumber = 3,
    kAnchorwiseOutputFieldNumber = 1,
    kSigmaFieldNumber = 2,
  };
  // repeated float code_weight = 3;
  int code_weight_size() const;
  private:
  int _internal_code_weight_size() const;
  public:
  void clear_code_weight();
  private:
  float _internal_code_weight(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_code_weight() const;
  void _internal_add_code_weight(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_code_weight();
  public:
  float code_weight(int index) const;
  void set_code_weight(int index, float value);
  void add_code_weight(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      code_weight() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_code_weight();

  // bool anchorwise_output = 1;
  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:

  // float sigma = 2;
  void clear_sigma();
  float sigma() const;
  void set_sigma(float value);
  private:
  float _internal_sigma() const;
  void _internal_set_sigma(float value);
  public:

  // @@protoc_insertion_point(class_scope:second.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::RepeatedField< float > code_weight_;
    bool anchorwise_output_;
    float sigma_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2flosses_2eproto;
};
// -------------------------------------------------------------------

class ClassificationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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,
    kBootstrappedSigmoid = 3,
    kWeightedSigmoidFocal = 4,
    kWeightedSoftmaxFocal = 5,
    CLASSIFICATION_LOSS_NOT_SET = 0,
  };

  static inline const ClassificationLoss* internal_default_instance() {
    return reinterpret_cast<const ClassificationLoss*>(
               &_ClassificationLoss_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  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 "second.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,
    kBootstrappedSigmoidFieldNumber = 3,
    kWeightedSigmoidFocalFieldNumber = 4,
    kWeightedSoftmaxFocalFieldNumber = 5,
  };
  // .second.protos.WeightedSigmoidClassificationLoss weighted_sigmoid = 1;
  bool has_weighted_sigmoid() const;
  private:
  bool _internal_has_weighted_sigmoid() const;
  public:
  void clear_weighted_sigmoid();
  const ::second::protos::WeightedSigmoidClassificationLoss& weighted_sigmoid() const;
  PROTOBUF_NODISCARD ::second::protos::WeightedSigmoidClassificationLoss* release_weighted_sigmoid();
  ::second::protos::WeightedSigmoidClassificationLoss* mutable_weighted_sigmoid();
  void set_allocated_weighted_sigmoid(::second::protos::WeightedSigmoidClassificationLoss* weighted_sigmoid);
  private:
  const ::second::protos::WeightedSigmoidClassificationLoss& _internal_weighted_sigmoid() const;
  ::second::protos::WeightedSigmoidClassificationLoss* _internal_mutable_weighted_sigmoid();
  public:
  void unsafe_arena_set_allocated_weighted_sigmoid(
      ::second::protos::WeightedSigmoidClassificationLoss* weighted_sigmoid);
  ::second::protos::WeightedSigmoidClassificationLoss* unsafe_arena_release_weighted_sigmoid();

  // .second.protos.WeightedSoftmaxClassificationLoss weighted_softmax = 2;
  bool has_weighted_softmax() const;
  private:
  bool _internal_has_weighted_softmax() const;
  public:
  void clear_weighted_softmax();
  const ::second::protos::WeightedSoftmaxClassificationLoss& weighted_softmax() const;
  PROTOBUF_NODISCARD ::second::protos::WeightedSoftmaxClassificationLoss* release_weighted_softmax();
  ::second::protos::WeightedSoftmaxClassificationLoss* mutable_weighted_softmax();
  void set_allocated_weighted_softmax(::second::protos::WeightedSoftmaxClassificationLoss* weighted_softmax);
  private:
  const ::second::protos::WeightedSoftmaxClassificationLoss& _internal_weighted_softmax() const;
  ::second::protos::WeightedSoftmaxClassificationLoss* _internal_mutable_weighted_softmax();
  public:
  void unsafe_arena_set_allocated_weighted_softmax(
      ::second::protos::WeightedSoftmaxClassificationLoss* weighted_softmax);
  ::second::protos::WeightedSoftmaxClassificationLoss* unsafe_arena_release_weighted_softmax();

  // .second.protos.BootstrappedSigmoidClassificationLoss bootstrapped_sigmoid = 3;
  bool has_bootstrapped_sigmoid() const;
  private:
  bool _internal_has_bootstrapped_sigmoid() const;
  public:
  void clear_bootstrapped_sigmoid();
  const ::second::protos::BootstrappedSigmoidClassificationLoss& bootstrapped_sigmoid() const;
  PROTOBUF_NODISCARD ::second::protos::BootstrappedSigmoidClassificationLoss* release_bootstrapped_sigmoid();
  ::second::protos::BootstrappedSigmoidClassificationLoss* mutable_bootstrapped_sigmoid();
  void set_allocated_bootstrapped_sigmoid(::second::protos::BootstrappedSigmoidClassificationLoss* bootstrapped_sigmoid);
  private:
  const ::second::protos::BootstrappedSigmoidClassificationLoss& _internal_bootstrapped_sigmoid() const;
  ::second::protos::BootstrappedSigmoidClassificationLoss* _internal_mutable_bootstrapped_sigmoid();
  public:
  void unsafe_arena_set_allocated_bootstrapped_sigmoid(
      ::second::protos::BootstrappedSigmoidClassificationLoss* bootstrapped_sigmoid);
  ::second::protos::BootstrappedSigmoidClassificationLoss* unsafe_arena_release_bootstrapped_sigmoid();

  // .second.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 ::second::protos::SigmoidFocalClassificationLoss& weighted_sigmoid_focal() const;
  PROTOBUF_NODISCARD ::second::protos::SigmoidFocalClassificationLoss* release_weighted_sigmoid_focal();
  ::second::protos::SigmoidFocalClassificationLoss* mutable_weighted_sigmoid_focal();
  void set_allocated_weighted_sigmoid_focal(::second::protos::SigmoidFocalClassificationLoss* weighted_sigmoid_focal);
  private:
  const ::second::protos::SigmoidFocalClassificationLoss& _internal_weighted_sigmoid_focal() const;
  ::second::protos::SigmoidFocalClassificationLoss* _internal_mutable_weighted_sigmoid_focal();
  public:
  void unsafe_arena_set_allocated_weighted_sigmoid_focal(
      ::second::protos::SigmoidFocalClassificationLoss* weighted_sigmoid_focal);
  ::second::protos::SigmoidFocalClassificationLoss* unsafe_arena_release_weighted_sigmoid_focal();

  // .second.protos.SoftmaxFocalClassificationLoss weighted_softmax_focal = 5;
  bool has_weighted_softmax_focal() const;
  private:
  bool _internal_has_weighted_softmax_focal() const;
  public:
  void clear_weighted_softmax_focal();
  const ::second::protos::SoftmaxFocalClassificationLoss& weighted_softmax_focal() const;
  PROTOBUF_NODISCARD ::second::protos::SoftmaxFocalClassificationLoss* release_weighted_softmax_focal();
  ::second::protos::SoftmaxFocalClassificationLoss* mutable_weighted_softmax_focal();
  void set_allocated_weighted_softmax_focal(::second::protos::SoftmaxFocalClassificationLoss* weighted_softmax_focal);
  private:
  const ::second::protos::SoftmaxFocalClassificationLoss& _internal_weighted_softmax_focal() const;
  ::second::protos::SoftmaxFocalClassificationLoss* _internal_mutable_weighted_softmax_focal();
  public:
  void unsafe_arena_set_allocated_weighted_softmax_focal(
      ::second::protos::SoftmaxFocalClassificationLoss* weighted_softmax_focal);
  ::second::protos::SoftmaxFocalClassificationLoss* unsafe_arena_release_weighted_softmax_focal();

  void clear_classification_loss();
  ClassificationLossCase classification_loss_case() const;
  // @@protoc_insertion_point(class_scope:second.protos.ClassificationLoss)
 private:
  class _Internal;
  void set_has_weighted_sigmoid();
  void set_has_weighted_softmax();
  void set_has_bootstrapped_sigmoid();
  void set_has_weighted_sigmoid_focal();
  void set_has_weighted_softmax_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_;
      ::second::protos::WeightedSigmoidClassificationLoss* weighted_sigmoid_;
      ::second::protos::WeightedSoftmaxClassificationLoss* weighted_softmax_;
      ::second::protos::BootstrappedSigmoidClassificationLoss* bootstrapped_sigmoid_;
      ::second::protos::SigmoidFocalClassificationLoss* weighted_sigmoid_focal_;
      ::second::protos::SoftmaxFocalClassificationLoss* weighted_softmax_focal_;
    } classification_loss_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

class WeightedSigmoidClassificationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    5;

  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 "second.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,
  };
  // bool anchorwise_output = 1;
  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:second.protos.WeightedSigmoidClassificationLoss)
 private:
  class _Internal;

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

class SigmoidFocalClassificationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    6;

  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 "second.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,
    kGammaFieldNumber = 2,
    kAlphaFieldNumber = 3,
  };
  // bool anchorwise_output = 1;
  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:

  // float gamma = 2;
  void clear_gamma();
  float gamma() const;
  void set_gamma(float value);
  private:
  float _internal_gamma() const;
  void _internal_set_gamma(float value);
  public:

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

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

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

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

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

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

  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 SoftmaxFocalClassificationLoss& default_instance() {
    return *internal_default_instance();
  }
  static inline const SoftmaxFocalClassificationLoss* internal_default_instance() {
    return reinterpret_cast<const SoftmaxFocalClassificationLoss*>(
               &_SoftmaxFocalClassificationLoss_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.SoftmaxFocalClassificationLoss";
  }
  protected:
  explicit SoftmaxFocalClassificationLoss(::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,
    kGammaFieldNumber = 2,
    kAlphaFieldNumber = 3,
  };
  // bool anchorwise_output = 1;
  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:

  // float gamma = 2;
  void clear_gamma();
  float gamma() const;
  void set_gamma(float value);
  private:
  float _internal_gamma() const;
  void _internal_set_gamma(float value);
  public:

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

  // @@protoc_insertion_point(class_scope:second.protos.SoftmaxFocalClassificationLoss)
 private:
  class _Internal;

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

class WeightedSoftmaxClassificationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    8;

  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 "second.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,
  };
  // bool anchorwise_output = 1;
  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:

  // float logit_scale = 2;
  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:second.protos.WeightedSoftmaxClassificationLoss)
 private:
  class _Internal;

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

class BootstrappedSigmoidClassificationLoss final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    9;

  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 "second.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,
  };
  // float alpha = 1;
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);
  private:
  float _internal_alpha() const;
  void _internal_set_alpha(float value);
  public:

  // bool hard_bootstrap = 2;
  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:

  // bool anchorwise_output = 3;
  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:second.protos.BootstrappedSigmoidClassificationLoss)
 private:
  class _Internal;

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

class HardExampleMiner final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.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;
  }

  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 =
    10;

  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 "second.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 {
    kNumHardExamplesFieldNumber = 1,
    kIouThresholdFieldNumber = 2,
    kLossTypeFieldNumber = 3,
    kMaxNegativesPerPositiveFieldNumber = 4,
    kMinNegativesPerImageFieldNumber = 5,
  };
  // int32 num_hard_examples = 1;
  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:

  // float iou_threshold = 2;
  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:

  // .second.protos.HardExampleMiner.LossType loss_type = 3;
  void clear_loss_type();
  ::second::protos::HardExampleMiner_LossType loss_type() const;
  void set_loss_type(::second::protos::HardExampleMiner_LossType value);
  private:
  ::second::protos::HardExampleMiner_LossType _internal_loss_type() const;
  void _internal_set_loss_type(::second::protos::HardExampleMiner_LossType value);
  public:

  // int32 max_negatives_per_positive = 4;
  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:

  // int32 min_negatives_per_image = 5;
  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:

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

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


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

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

// .second.protos.LocalizationLoss localization_loss = 1;
inline bool Loss::_internal_has_localization_loss() const {
  return this != internal_default_instance() && _impl_.localization_loss_ != nullptr;
}
inline bool Loss::has_localization_loss() const {
  return _internal_has_localization_loss();
}
inline void Loss::clear_localization_loss() {
  if (GetArenaForAllocation() == nullptr && _impl_.localization_loss_ != nullptr) {
    delete _impl_.localization_loss_;
  }
  _impl_.localization_loss_ = nullptr;
}
inline const ::second::protos::LocalizationLoss& Loss::_internal_localization_loss() const {
  const ::second::protos::LocalizationLoss* p = _impl_.localization_loss_;
  return p != nullptr ? *p : reinterpret_cast<const ::second::protos::LocalizationLoss&>(
      ::second::protos::_LocalizationLoss_default_instance_);
}
inline const ::second::protos::LocalizationLoss& Loss::localization_loss() const {
  // @@protoc_insertion_point(field_get:second.protos.Loss.localization_loss)
  return _internal_localization_loss();
}
inline void Loss::unsafe_arena_set_allocated_localization_loss(
    ::second::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) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Loss.localization_loss)
}
inline ::second::protos::LocalizationLoss* Loss::release_localization_loss() {
  
  ::second::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 ::second::protos::LocalizationLoss* Loss::unsafe_arena_release_localization_loss() {
  // @@protoc_insertion_point(field_release:second.protos.Loss.localization_loss)
  
  ::second::protos::LocalizationLoss* temp = _impl_.localization_loss_;
  _impl_.localization_loss_ = nullptr;
  return temp;
}
inline ::second::protos::LocalizationLoss* Loss::_internal_mutable_localization_loss() {
  
  if (_impl_.localization_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::second::protos::LocalizationLoss>(GetArenaForAllocation());
    _impl_.localization_loss_ = p;
  }
  return _impl_.localization_loss_;
}
inline ::second::protos::LocalizationLoss* Loss::mutable_localization_loss() {
  ::second::protos::LocalizationLoss* _msg = _internal_mutable_localization_loss();
  // @@protoc_insertion_point(field_mutable:second.protos.Loss.localization_loss)
  return _msg;
}
inline void Loss::set_allocated_localization_loss(::second::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);
    }
    
  } else {
    
  }
  _impl_.localization_loss_ = localization_loss;
  // @@protoc_insertion_point(field_set_allocated:second.protos.Loss.localization_loss)
}

// .second.protos.ClassificationLoss classification_loss = 2;
inline bool Loss::_internal_has_classification_loss() const {
  return this != internal_default_instance() && _impl_.classification_loss_ != nullptr;
}
inline bool Loss::has_classification_loss() const {
  return _internal_has_classification_loss();
}
inline void Loss::clear_classification_loss() {
  if (GetArenaForAllocation() == nullptr && _impl_.classification_loss_ != nullptr) {
    delete _impl_.classification_loss_;
  }
  _impl_.classification_loss_ = nullptr;
}
inline const ::second::protos::ClassificationLoss& Loss::_internal_classification_loss() const {
  const ::second::protos::ClassificationLoss* p = _impl_.classification_loss_;
  return p != nullptr ? *p : reinterpret_cast<const ::second::protos::ClassificationLoss&>(
      ::second::protos::_ClassificationLoss_default_instance_);
}
inline const ::second::protos::ClassificationLoss& Loss::classification_loss() const {
  // @@protoc_insertion_point(field_get:second.protos.Loss.classification_loss)
  return _internal_classification_loss();
}
inline void Loss::unsafe_arena_set_allocated_classification_loss(
    ::second::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) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Loss.classification_loss)
}
inline ::second::protos::ClassificationLoss* Loss::release_classification_loss() {
  
  ::second::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 ::second::protos::ClassificationLoss* Loss::unsafe_arena_release_classification_loss() {
  // @@protoc_insertion_point(field_release:second.protos.Loss.classification_loss)
  
  ::second::protos::ClassificationLoss* temp = _impl_.classification_loss_;
  _impl_.classification_loss_ = nullptr;
  return temp;
}
inline ::second::protos::ClassificationLoss* Loss::_internal_mutable_classification_loss() {
  
  if (_impl_.classification_loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::second::protos::ClassificationLoss>(GetArenaForAllocation());
    _impl_.classification_loss_ = p;
  }
  return _impl_.classification_loss_;
}
inline ::second::protos::ClassificationLoss* Loss::mutable_classification_loss() {
  ::second::protos::ClassificationLoss* _msg = _internal_mutable_classification_loss();
  // @@protoc_insertion_point(field_mutable:second.protos.Loss.classification_loss)
  return _msg;
}
inline void Loss::set_allocated_classification_loss(::second::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);
    }
    
  } else {
    
  }
  _impl_.classification_loss_ = classification_loss;
  // @@protoc_insertion_point(field_set_allocated:second.protos.Loss.classification_loss)
}

// .second.protos.HardExampleMiner hard_example_miner = 3;
inline bool Loss::_internal_has_hard_example_miner() const {
  return this != internal_default_instance() && _impl_.hard_example_miner_ != nullptr;
}
inline bool Loss::has_hard_example_miner() const {
  return _internal_has_hard_example_miner();
}
inline void Loss::clear_hard_example_miner() {
  if (GetArenaForAllocation() == nullptr && _impl_.hard_example_miner_ != nullptr) {
    delete _impl_.hard_example_miner_;
  }
  _impl_.hard_example_miner_ = nullptr;
}
inline const ::second::protos::HardExampleMiner& Loss::_internal_hard_example_miner() const {
  const ::second::protos::HardExampleMiner* p = _impl_.hard_example_miner_;
  return p != nullptr ? *p : reinterpret_cast<const ::second::protos::HardExampleMiner&>(
      ::second::protos::_HardExampleMiner_default_instance_);
}
inline const ::second::protos::HardExampleMiner& Loss::hard_example_miner() const {
  // @@protoc_insertion_point(field_get:second.protos.Loss.hard_example_miner)
  return _internal_hard_example_miner();
}
inline void Loss::unsafe_arena_set_allocated_hard_example_miner(
    ::second::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) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Loss.hard_example_miner)
}
inline ::second::protos::HardExampleMiner* Loss::release_hard_example_miner() {
  
  ::second::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 ::second::protos::HardExampleMiner* Loss::unsafe_arena_release_hard_example_miner() {
  // @@protoc_insertion_point(field_release:second.protos.Loss.hard_example_miner)
  
  ::second::protos::HardExampleMiner* temp = _impl_.hard_example_miner_;
  _impl_.hard_example_miner_ = nullptr;
  return temp;
}
inline ::second::protos::HardExampleMiner* Loss::_internal_mutable_hard_example_miner() {
  
  if (_impl_.hard_example_miner_ == nullptr) {
    auto* p = CreateMaybeMessage<::second::protos::HardExampleMiner>(GetArenaForAllocation());
    _impl_.hard_example_miner_ = p;
  }
  return _impl_.hard_example_miner_;
}
inline ::second::protos::HardExampleMiner* Loss::mutable_hard_example_miner() {
  ::second::protos::HardExampleMiner* _msg = _internal_mutable_hard_example_miner();
  // @@protoc_insertion_point(field_mutable:second.protos.Loss.hard_example_miner)
  return _msg;
}
inline void Loss::set_allocated_hard_example_miner(::second::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);
    }
    
  } else {
    
  }
  _impl_.hard_example_miner_ = hard_example_miner;
  // @@protoc_insertion_point(field_set_allocated:second.protos.Loss.hard_example_miner)
}

// float classification_weight = 4;
inline void Loss::clear_classification_weight() {
  _impl_.classification_weight_ = 0;
}
inline float Loss::_internal_classification_weight() const {
  return _impl_.classification_weight_;
}
inline float Loss::classification_weight() const {
  // @@protoc_insertion_point(field_get:second.protos.Loss.classification_weight)
  return _internal_classification_weight();
}
inline void Loss::_internal_set_classification_weight(float value) {
  
  _impl_.classification_weight_ = value;
}
inline void Loss::set_classification_weight(float value) {
  _internal_set_classification_weight(value);
  // @@protoc_insertion_point(field_set:second.protos.Loss.classification_weight)
}

// float localization_weight = 5;
inline void Loss::clear_localization_weight() {
  _impl_.localization_weight_ = 0;
}
inline float Loss::_internal_localization_weight() const {
  return _impl_.localization_weight_;
}
inline float Loss::localization_weight() const {
  // @@protoc_insertion_point(field_get:second.protos.Loss.localization_weight)
  return _internal_localization_weight();
}
inline void Loss::_internal_set_localization_weight(float value) {
  
  _impl_.localization_weight_ = value;
}
inline void Loss::set_localization_weight(float value) {
  _internal_set_localization_weight(value);
  // @@protoc_insertion_point(field_set:second.protos.Loss.localization_weight)
}

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

// LocalizationLoss

// .second.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 ::second::protos::WeightedL2LocalizationLoss* LocalizationLoss::release_weighted_l2() {
  // @@protoc_insertion_point(field_release:second.protos.LocalizationLoss.weighted_l2)
  if (_internal_has_weighted_l2()) {
    clear_has_localization_loss();
    ::second::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 ::second::protos::WeightedL2LocalizationLoss& LocalizationLoss::_internal_weighted_l2() const {
  return _internal_has_weighted_l2()
      ? *_impl_.localization_loss_.weighted_l2_
      : reinterpret_cast< ::second::protos::WeightedL2LocalizationLoss&>(::second::protos::_WeightedL2LocalizationLoss_default_instance_);
}
inline const ::second::protos::WeightedL2LocalizationLoss& LocalizationLoss::weighted_l2() const {
  // @@protoc_insertion_point(field_get:second.protos.LocalizationLoss.weighted_l2)
  return _internal_weighted_l2();
}
inline ::second::protos::WeightedL2LocalizationLoss* LocalizationLoss::unsafe_arena_release_weighted_l2() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.LocalizationLoss.weighted_l2)
  if (_internal_has_weighted_l2()) {
    clear_has_localization_loss();
    ::second::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(::second::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:second.protos.LocalizationLoss.weighted_l2)
}
inline ::second::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< ::second::protos::WeightedL2LocalizationLoss >(GetArenaForAllocation());
  }
  return _impl_.localization_loss_.weighted_l2_;
}
inline ::second::protos::WeightedL2LocalizationLoss* LocalizationLoss::mutable_weighted_l2() {
  ::second::protos::WeightedL2LocalizationLoss* _msg = _internal_mutable_weighted_l2();
  // @@protoc_insertion_point(field_mutable:second.protos.LocalizationLoss.weighted_l2)
  return _msg;
}

// .second.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 ::second::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::release_weighted_smooth_l1() {
  // @@protoc_insertion_point(field_release:second.protos.LocalizationLoss.weighted_smooth_l1)
  if (_internal_has_weighted_smooth_l1()) {
    clear_has_localization_loss();
    ::second::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 ::second::protos::WeightedSmoothL1LocalizationLoss& LocalizationLoss::_internal_weighted_smooth_l1() const {
  return _internal_has_weighted_smooth_l1()
      ? *_impl_.localization_loss_.weighted_smooth_l1_
      : reinterpret_cast< ::second::protos::WeightedSmoothL1LocalizationLoss&>(::second::protos::_WeightedSmoothL1LocalizationLoss_default_instance_);
}
inline const ::second::protos::WeightedSmoothL1LocalizationLoss& LocalizationLoss::weighted_smooth_l1() const {
  // @@protoc_insertion_point(field_get:second.protos.LocalizationLoss.weighted_smooth_l1)
  return _internal_weighted_smooth_l1();
}
inline ::second::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::unsafe_arena_release_weighted_smooth_l1() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.LocalizationLoss.weighted_smooth_l1)
  if (_internal_has_weighted_smooth_l1()) {
    clear_has_localization_loss();
    ::second::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(::second::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:second.protos.LocalizationLoss.weighted_smooth_l1)
}
inline ::second::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< ::second::protos::WeightedSmoothL1LocalizationLoss >(GetArenaForAllocation());
  }
  return _impl_.localization_loss_.weighted_smooth_l1_;
}
inline ::second::protos::WeightedSmoothL1LocalizationLoss* LocalizationLoss::mutable_weighted_smooth_l1() {
  ::second::protos::WeightedSmoothL1LocalizationLoss* _msg = _internal_mutable_weighted_smooth_l1();
  // @@protoc_insertion_point(field_mutable:second.protos.LocalizationLoss.weighted_smooth_l1)
  return _msg;
}

// bool encode_rad_error_by_sin = 3;
inline void LocalizationLoss::clear_encode_rad_error_by_sin() {
  _impl_.encode_rad_error_by_sin_ = false;
}
inline bool LocalizationLoss::_internal_encode_rad_error_by_sin() const {
  return _impl_.encode_rad_error_by_sin_;
}
inline bool LocalizationLoss::encode_rad_error_by_sin() const {
  // @@protoc_insertion_point(field_get:second.protos.LocalizationLoss.encode_rad_error_by_sin)
  return _internal_encode_rad_error_by_sin();
}
inline void LocalizationLoss::_internal_set_encode_rad_error_by_sin(bool value) {
  
  _impl_.encode_rad_error_by_sin_ = value;
}
inline void LocalizationLoss::set_encode_rad_error_by_sin(bool value) {
  _internal_set_encode_rad_error_by_sin(value);
  // @@protoc_insertion_point(field_set:second.protos.LocalizationLoss.encode_rad_error_by_sin)
}

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

// bool anchorwise_output = 1;
inline void WeightedL2LocalizationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
}
inline bool WeightedL2LocalizationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedL2LocalizationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedL2LocalizationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedL2LocalizationLoss::_internal_set_anchorwise_output(bool value) {
  
  _impl_.anchorwise_output_ = value;
}
inline void WeightedL2LocalizationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedL2LocalizationLoss.anchorwise_output)
}

// repeated float code_weight = 2;
inline int WeightedL2LocalizationLoss::_internal_code_weight_size() const {
  return _impl_.code_weight_.size();
}
inline int WeightedL2LocalizationLoss::code_weight_size() const {
  return _internal_code_weight_size();
}
inline void WeightedL2LocalizationLoss::clear_code_weight() {
  _impl_.code_weight_.Clear();
}
inline float WeightedL2LocalizationLoss::_internal_code_weight(int index) const {
  return _impl_.code_weight_.Get(index);
}
inline float WeightedL2LocalizationLoss::code_weight(int index) const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedL2LocalizationLoss.code_weight)
  return _internal_code_weight(index);
}
inline void WeightedL2LocalizationLoss::set_code_weight(int index, float value) {
  _impl_.code_weight_.Set(index, value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedL2LocalizationLoss.code_weight)
}
inline void WeightedL2LocalizationLoss::_internal_add_code_weight(float value) {
  _impl_.code_weight_.Add(value);
}
inline void WeightedL2LocalizationLoss::add_code_weight(float value) {
  _internal_add_code_weight(value);
  // @@protoc_insertion_point(field_add:second.protos.WeightedL2LocalizationLoss.code_weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
WeightedL2LocalizationLoss::_internal_code_weight() const {
  return _impl_.code_weight_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
WeightedL2LocalizationLoss::code_weight() const {
  // @@protoc_insertion_point(field_list:second.protos.WeightedL2LocalizationLoss.code_weight)
  return _internal_code_weight();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
WeightedL2LocalizationLoss::_internal_mutable_code_weight() {
  return &_impl_.code_weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
WeightedL2LocalizationLoss::mutable_code_weight() {
  // @@protoc_insertion_point(field_mutable_list:second.protos.WeightedL2LocalizationLoss.code_weight)
  return _internal_mutable_code_weight();
}

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

// WeightedSmoothL1LocalizationLoss

// bool anchorwise_output = 1;
inline void WeightedSmoothL1LocalizationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
}
inline bool WeightedSmoothL1LocalizationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedSmoothL1LocalizationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedSmoothL1LocalizationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedSmoothL1LocalizationLoss::_internal_set_anchorwise_output(bool value) {
  
  _impl_.anchorwise_output_ = value;
}
inline void WeightedSmoothL1LocalizationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedSmoothL1LocalizationLoss.anchorwise_output)
}

// float sigma = 2;
inline void WeightedSmoothL1LocalizationLoss::clear_sigma() {
  _impl_.sigma_ = 0;
}
inline float WeightedSmoothL1LocalizationLoss::_internal_sigma() const {
  return _impl_.sigma_;
}
inline float WeightedSmoothL1LocalizationLoss::sigma() const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedSmoothL1LocalizationLoss.sigma)
  return _internal_sigma();
}
inline void WeightedSmoothL1LocalizationLoss::_internal_set_sigma(float value) {
  
  _impl_.sigma_ = value;
}
inline void WeightedSmoothL1LocalizationLoss::set_sigma(float value) {
  _internal_set_sigma(value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedSmoothL1LocalizationLoss.sigma)
}

// repeated float code_weight = 3;
inline int WeightedSmoothL1LocalizationLoss::_internal_code_weight_size() const {
  return _impl_.code_weight_.size();
}
inline int WeightedSmoothL1LocalizationLoss::code_weight_size() const {
  return _internal_code_weight_size();
}
inline void WeightedSmoothL1LocalizationLoss::clear_code_weight() {
  _impl_.code_weight_.Clear();
}
inline float WeightedSmoothL1LocalizationLoss::_internal_code_weight(int index) const {
  return _impl_.code_weight_.Get(index);
}
inline float WeightedSmoothL1LocalizationLoss::code_weight(int index) const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedSmoothL1LocalizationLoss.code_weight)
  return _internal_code_weight(index);
}
inline void WeightedSmoothL1LocalizationLoss::set_code_weight(int index, float value) {
  _impl_.code_weight_.Set(index, value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedSmoothL1LocalizationLoss.code_weight)
}
inline void WeightedSmoothL1LocalizationLoss::_internal_add_code_weight(float value) {
  _impl_.code_weight_.Add(value);
}
inline void WeightedSmoothL1LocalizationLoss::add_code_weight(float value) {
  _internal_add_code_weight(value);
  // @@protoc_insertion_point(field_add:second.protos.WeightedSmoothL1LocalizationLoss.code_weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
WeightedSmoothL1LocalizationLoss::_internal_code_weight() const {
  return _impl_.code_weight_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
WeightedSmoothL1LocalizationLoss::code_weight() const {
  // @@protoc_insertion_point(field_list:second.protos.WeightedSmoothL1LocalizationLoss.code_weight)
  return _internal_code_weight();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
WeightedSmoothL1LocalizationLoss::_internal_mutable_code_weight() {
  return &_impl_.code_weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
WeightedSmoothL1LocalizationLoss::mutable_code_weight() {
  // @@protoc_insertion_point(field_mutable_list:second.protos.WeightedSmoothL1LocalizationLoss.code_weight)
  return _internal_mutable_code_weight();
}

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

// ClassificationLoss

// .second.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 ::second::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::release_weighted_sigmoid() {
  // @@protoc_insertion_point(field_release:second.protos.ClassificationLoss.weighted_sigmoid)
  if (_internal_has_weighted_sigmoid()) {
    clear_has_classification_loss();
    ::second::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 ::second::protos::WeightedSigmoidClassificationLoss& ClassificationLoss::_internal_weighted_sigmoid() const {
  return _internal_has_weighted_sigmoid()
      ? *_impl_.classification_loss_.weighted_sigmoid_
      : reinterpret_cast< ::second::protos::WeightedSigmoidClassificationLoss&>(::second::protos::_WeightedSigmoidClassificationLoss_default_instance_);
}
inline const ::second::protos::WeightedSigmoidClassificationLoss& ClassificationLoss::weighted_sigmoid() const {
  // @@protoc_insertion_point(field_get:second.protos.ClassificationLoss.weighted_sigmoid)
  return _internal_weighted_sigmoid();
}
inline ::second::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::unsafe_arena_release_weighted_sigmoid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.ClassificationLoss.weighted_sigmoid)
  if (_internal_has_weighted_sigmoid()) {
    clear_has_classification_loss();
    ::second::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(::second::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:second.protos.ClassificationLoss.weighted_sigmoid)
}
inline ::second::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< ::second::protos::WeightedSigmoidClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_sigmoid_;
}
inline ::second::protos::WeightedSigmoidClassificationLoss* ClassificationLoss::mutable_weighted_sigmoid() {
  ::second::protos::WeightedSigmoidClassificationLoss* _msg = _internal_mutable_weighted_sigmoid();
  // @@protoc_insertion_point(field_mutable:second.protos.ClassificationLoss.weighted_sigmoid)
  return _msg;
}

// .second.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 ::second::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::release_weighted_softmax() {
  // @@protoc_insertion_point(field_release:second.protos.ClassificationLoss.weighted_softmax)
  if (_internal_has_weighted_softmax()) {
    clear_has_classification_loss();
    ::second::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 ::second::protos::WeightedSoftmaxClassificationLoss& ClassificationLoss::_internal_weighted_softmax() const {
  return _internal_has_weighted_softmax()
      ? *_impl_.classification_loss_.weighted_softmax_
      : reinterpret_cast< ::second::protos::WeightedSoftmaxClassificationLoss&>(::second::protos::_WeightedSoftmaxClassificationLoss_default_instance_);
}
inline const ::second::protos::WeightedSoftmaxClassificationLoss& ClassificationLoss::weighted_softmax() const {
  // @@protoc_insertion_point(field_get:second.protos.ClassificationLoss.weighted_softmax)
  return _internal_weighted_softmax();
}
inline ::second::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::unsafe_arena_release_weighted_softmax() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.ClassificationLoss.weighted_softmax)
  if (_internal_has_weighted_softmax()) {
    clear_has_classification_loss();
    ::second::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(::second::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:second.protos.ClassificationLoss.weighted_softmax)
}
inline ::second::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< ::second::protos::WeightedSoftmaxClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_softmax_;
}
inline ::second::protos::WeightedSoftmaxClassificationLoss* ClassificationLoss::mutable_weighted_softmax() {
  ::second::protos::WeightedSoftmaxClassificationLoss* _msg = _internal_mutable_weighted_softmax();
  // @@protoc_insertion_point(field_mutable:second.protos.ClassificationLoss.weighted_softmax)
  return _msg;
}

// .second.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 ::second::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::release_bootstrapped_sigmoid() {
  // @@protoc_insertion_point(field_release:second.protos.ClassificationLoss.bootstrapped_sigmoid)
  if (_internal_has_bootstrapped_sigmoid()) {
    clear_has_classification_loss();
    ::second::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 ::second::protos::BootstrappedSigmoidClassificationLoss& ClassificationLoss::_internal_bootstrapped_sigmoid() const {
  return _internal_has_bootstrapped_sigmoid()
      ? *_impl_.classification_loss_.bootstrapped_sigmoid_
      : reinterpret_cast< ::second::protos::BootstrappedSigmoidClassificationLoss&>(::second::protos::_BootstrappedSigmoidClassificationLoss_default_instance_);
}
inline const ::second::protos::BootstrappedSigmoidClassificationLoss& ClassificationLoss::bootstrapped_sigmoid() const {
  // @@protoc_insertion_point(field_get:second.protos.ClassificationLoss.bootstrapped_sigmoid)
  return _internal_bootstrapped_sigmoid();
}
inline ::second::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::unsafe_arena_release_bootstrapped_sigmoid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.ClassificationLoss.bootstrapped_sigmoid)
  if (_internal_has_bootstrapped_sigmoid()) {
    clear_has_classification_loss();
    ::second::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(::second::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:second.protos.ClassificationLoss.bootstrapped_sigmoid)
}
inline ::second::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< ::second::protos::BootstrappedSigmoidClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.bootstrapped_sigmoid_;
}
inline ::second::protos::BootstrappedSigmoidClassificationLoss* ClassificationLoss::mutable_bootstrapped_sigmoid() {
  ::second::protos::BootstrappedSigmoidClassificationLoss* _msg = _internal_mutable_bootstrapped_sigmoid();
  // @@protoc_insertion_point(field_mutable:second.protos.ClassificationLoss.bootstrapped_sigmoid)
  return _msg;
}

// .second.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 ::second::protos::SigmoidFocalClassificationLoss* ClassificationLoss::release_weighted_sigmoid_focal() {
  // @@protoc_insertion_point(field_release:second.protos.ClassificationLoss.weighted_sigmoid_focal)
  if (_internal_has_weighted_sigmoid_focal()) {
    clear_has_classification_loss();
    ::second::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 ::second::protos::SigmoidFocalClassificationLoss& ClassificationLoss::_internal_weighted_sigmoid_focal() const {
  return _internal_has_weighted_sigmoid_focal()
      ? *_impl_.classification_loss_.weighted_sigmoid_focal_
      : reinterpret_cast< ::second::protos::SigmoidFocalClassificationLoss&>(::second::protos::_SigmoidFocalClassificationLoss_default_instance_);
}
inline const ::second::protos::SigmoidFocalClassificationLoss& ClassificationLoss::weighted_sigmoid_focal() const {
  // @@protoc_insertion_point(field_get:second.protos.ClassificationLoss.weighted_sigmoid_focal)
  return _internal_weighted_sigmoid_focal();
}
inline ::second::protos::SigmoidFocalClassificationLoss* ClassificationLoss::unsafe_arena_release_weighted_sigmoid_focal() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.ClassificationLoss.weighted_sigmoid_focal)
  if (_internal_has_weighted_sigmoid_focal()) {
    clear_has_classification_loss();
    ::second::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(::second::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:second.protos.ClassificationLoss.weighted_sigmoid_focal)
}
inline ::second::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< ::second::protos::SigmoidFocalClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_sigmoid_focal_;
}
inline ::second::protos::SigmoidFocalClassificationLoss* ClassificationLoss::mutable_weighted_sigmoid_focal() {
  ::second::protos::SigmoidFocalClassificationLoss* _msg = _internal_mutable_weighted_sigmoid_focal();
  // @@protoc_insertion_point(field_mutable:second.protos.ClassificationLoss.weighted_sigmoid_focal)
  return _msg;
}

// .second.protos.SoftmaxFocalClassificationLoss weighted_softmax_focal = 5;
inline bool ClassificationLoss::_internal_has_weighted_softmax_focal() const {
  return classification_loss_case() == kWeightedSoftmaxFocal;
}
inline bool ClassificationLoss::has_weighted_softmax_focal() const {
  return _internal_has_weighted_softmax_focal();
}
inline void ClassificationLoss::set_has_weighted_softmax_focal() {
  _impl_._oneof_case_[0] = kWeightedSoftmaxFocal;
}
inline void ClassificationLoss::clear_weighted_softmax_focal() {
  if (_internal_has_weighted_softmax_focal()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.classification_loss_.weighted_softmax_focal_;
    }
    clear_has_classification_loss();
  }
}
inline ::second::protos::SoftmaxFocalClassificationLoss* ClassificationLoss::release_weighted_softmax_focal() {
  // @@protoc_insertion_point(field_release:second.protos.ClassificationLoss.weighted_softmax_focal)
  if (_internal_has_weighted_softmax_focal()) {
    clear_has_classification_loss();
    ::second::protos::SoftmaxFocalClassificationLoss* temp = _impl_.classification_loss_.weighted_softmax_focal_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.classification_loss_.weighted_softmax_focal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::SoftmaxFocalClassificationLoss& ClassificationLoss::_internal_weighted_softmax_focal() const {
  return _internal_has_weighted_softmax_focal()
      ? *_impl_.classification_loss_.weighted_softmax_focal_
      : reinterpret_cast< ::second::protos::SoftmaxFocalClassificationLoss&>(::second::protos::_SoftmaxFocalClassificationLoss_default_instance_);
}
inline const ::second::protos::SoftmaxFocalClassificationLoss& ClassificationLoss::weighted_softmax_focal() const {
  // @@protoc_insertion_point(field_get:second.protos.ClassificationLoss.weighted_softmax_focal)
  return _internal_weighted_softmax_focal();
}
inline ::second::protos::SoftmaxFocalClassificationLoss* ClassificationLoss::unsafe_arena_release_weighted_softmax_focal() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.ClassificationLoss.weighted_softmax_focal)
  if (_internal_has_weighted_softmax_focal()) {
    clear_has_classification_loss();
    ::second::protos::SoftmaxFocalClassificationLoss* temp = _impl_.classification_loss_.weighted_softmax_focal_;
    _impl_.classification_loss_.weighted_softmax_focal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClassificationLoss::unsafe_arena_set_allocated_weighted_softmax_focal(::second::protos::SoftmaxFocalClassificationLoss* weighted_softmax_focal) {
  clear_classification_loss();
  if (weighted_softmax_focal) {
    set_has_weighted_softmax_focal();
    _impl_.classification_loss_.weighted_softmax_focal_ = weighted_softmax_focal;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.ClassificationLoss.weighted_softmax_focal)
}
inline ::second::protos::SoftmaxFocalClassificationLoss* ClassificationLoss::_internal_mutable_weighted_softmax_focal() {
  if (!_internal_has_weighted_softmax_focal()) {
    clear_classification_loss();
    set_has_weighted_softmax_focal();
    _impl_.classification_loss_.weighted_softmax_focal_ = CreateMaybeMessage< ::second::protos::SoftmaxFocalClassificationLoss >(GetArenaForAllocation());
  }
  return _impl_.classification_loss_.weighted_softmax_focal_;
}
inline ::second::protos::SoftmaxFocalClassificationLoss* ClassificationLoss::mutable_weighted_softmax_focal() {
  ::second::protos::SoftmaxFocalClassificationLoss* _msg = _internal_mutable_weighted_softmax_focal();
  // @@protoc_insertion_point(field_mutable:second.protos.ClassificationLoss.weighted_softmax_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

// bool anchorwise_output = 1;
inline void WeightedSigmoidClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
}
inline bool WeightedSigmoidClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedSigmoidClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedSigmoidClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedSigmoidClassificationLoss::_internal_set_anchorwise_output(bool value) {
  
  _impl_.anchorwise_output_ = value;
}
inline void WeightedSigmoidClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedSigmoidClassificationLoss.anchorwise_output)
}

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

// SigmoidFocalClassificationLoss

// bool anchorwise_output = 1;
inline void SigmoidFocalClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
}
inline bool SigmoidFocalClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool SigmoidFocalClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:second.protos.SigmoidFocalClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void SigmoidFocalClassificationLoss::_internal_set_anchorwise_output(bool value) {
  
  _impl_.anchorwise_output_ = value;
}
inline void SigmoidFocalClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:second.protos.SigmoidFocalClassificationLoss.anchorwise_output)
}

// float gamma = 2;
inline void SigmoidFocalClassificationLoss::clear_gamma() {
  _impl_.gamma_ = 0;
}
inline float SigmoidFocalClassificationLoss::_internal_gamma() const {
  return _impl_.gamma_;
}
inline float SigmoidFocalClassificationLoss::gamma() const {
  // @@protoc_insertion_point(field_get:second.protos.SigmoidFocalClassificationLoss.gamma)
  return _internal_gamma();
}
inline void SigmoidFocalClassificationLoss::_internal_set_gamma(float value) {
  
  _impl_.gamma_ = value;
}
inline void SigmoidFocalClassificationLoss::set_gamma(float value) {
  _internal_set_gamma(value);
  // @@protoc_insertion_point(field_set:second.protos.SigmoidFocalClassificationLoss.gamma)
}

// float alpha = 3;
inline void SigmoidFocalClassificationLoss::clear_alpha() {
  _impl_.alpha_ = 0;
}
inline float SigmoidFocalClassificationLoss::_internal_alpha() const {
  return _impl_.alpha_;
}
inline float SigmoidFocalClassificationLoss::alpha() const {
  // @@protoc_insertion_point(field_get:second.protos.SigmoidFocalClassificationLoss.alpha)
  return _internal_alpha();
}
inline void SigmoidFocalClassificationLoss::_internal_set_alpha(float value) {
  
  _impl_.alpha_ = value;
}
inline void SigmoidFocalClassificationLoss::set_alpha(float value) {
  _internal_set_alpha(value);
  // @@protoc_insertion_point(field_set:second.protos.SigmoidFocalClassificationLoss.alpha)
}

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

// SoftmaxFocalClassificationLoss

// bool anchorwise_output = 1;
inline void SoftmaxFocalClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
}
inline bool SoftmaxFocalClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool SoftmaxFocalClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:second.protos.SoftmaxFocalClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void SoftmaxFocalClassificationLoss::_internal_set_anchorwise_output(bool value) {
  
  _impl_.anchorwise_output_ = value;
}
inline void SoftmaxFocalClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:second.protos.SoftmaxFocalClassificationLoss.anchorwise_output)
}

// float gamma = 2;
inline void SoftmaxFocalClassificationLoss::clear_gamma() {
  _impl_.gamma_ = 0;
}
inline float SoftmaxFocalClassificationLoss::_internal_gamma() const {
  return _impl_.gamma_;
}
inline float SoftmaxFocalClassificationLoss::gamma() const {
  // @@protoc_insertion_point(field_get:second.protos.SoftmaxFocalClassificationLoss.gamma)
  return _internal_gamma();
}
inline void SoftmaxFocalClassificationLoss::_internal_set_gamma(float value) {
  
  _impl_.gamma_ = value;
}
inline void SoftmaxFocalClassificationLoss::set_gamma(float value) {
  _internal_set_gamma(value);
  // @@protoc_insertion_point(field_set:second.protos.SoftmaxFocalClassificationLoss.gamma)
}

// float alpha = 3;
inline void SoftmaxFocalClassificationLoss::clear_alpha() {
  _impl_.alpha_ = 0;
}
inline float SoftmaxFocalClassificationLoss::_internal_alpha() const {
  return _impl_.alpha_;
}
inline float SoftmaxFocalClassificationLoss::alpha() const {
  // @@protoc_insertion_point(field_get:second.protos.SoftmaxFocalClassificationLoss.alpha)
  return _internal_alpha();
}
inline void SoftmaxFocalClassificationLoss::_internal_set_alpha(float value) {
  
  _impl_.alpha_ = value;
}
inline void SoftmaxFocalClassificationLoss::set_alpha(float value) {
  _internal_set_alpha(value);
  // @@protoc_insertion_point(field_set:second.protos.SoftmaxFocalClassificationLoss.alpha)
}

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

// WeightedSoftmaxClassificationLoss

// bool anchorwise_output = 1;
inline void WeightedSoftmaxClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
}
inline bool WeightedSoftmaxClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool WeightedSoftmaxClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedSoftmaxClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void WeightedSoftmaxClassificationLoss::_internal_set_anchorwise_output(bool value) {
  
  _impl_.anchorwise_output_ = value;
}
inline void WeightedSoftmaxClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedSoftmaxClassificationLoss.anchorwise_output)
}

// float logit_scale = 2;
inline void WeightedSoftmaxClassificationLoss::clear_logit_scale() {
  _impl_.logit_scale_ = 0;
}
inline float WeightedSoftmaxClassificationLoss::_internal_logit_scale() const {
  return _impl_.logit_scale_;
}
inline float WeightedSoftmaxClassificationLoss::logit_scale() const {
  // @@protoc_insertion_point(field_get:second.protos.WeightedSoftmaxClassificationLoss.logit_scale)
  return _internal_logit_scale();
}
inline void WeightedSoftmaxClassificationLoss::_internal_set_logit_scale(float value) {
  
  _impl_.logit_scale_ = value;
}
inline void WeightedSoftmaxClassificationLoss::set_logit_scale(float value) {
  _internal_set_logit_scale(value);
  // @@protoc_insertion_point(field_set:second.protos.WeightedSoftmaxClassificationLoss.logit_scale)
}

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

// BootstrappedSigmoidClassificationLoss

// float alpha = 1;
inline void BootstrappedSigmoidClassificationLoss::clear_alpha() {
  _impl_.alpha_ = 0;
}
inline float BootstrappedSigmoidClassificationLoss::_internal_alpha() const {
  return _impl_.alpha_;
}
inline float BootstrappedSigmoidClassificationLoss::alpha() const {
  // @@protoc_insertion_point(field_get:second.protos.BootstrappedSigmoidClassificationLoss.alpha)
  return _internal_alpha();
}
inline void BootstrappedSigmoidClassificationLoss::_internal_set_alpha(float value) {
  
  _impl_.alpha_ = value;
}
inline void BootstrappedSigmoidClassificationLoss::set_alpha(float value) {
  _internal_set_alpha(value);
  // @@protoc_insertion_point(field_set:second.protos.BootstrappedSigmoidClassificationLoss.alpha)
}

// bool hard_bootstrap = 2;
inline void BootstrappedSigmoidClassificationLoss::clear_hard_bootstrap() {
  _impl_.hard_bootstrap_ = false;
}
inline bool BootstrappedSigmoidClassificationLoss::_internal_hard_bootstrap() const {
  return _impl_.hard_bootstrap_;
}
inline bool BootstrappedSigmoidClassificationLoss::hard_bootstrap() const {
  // @@protoc_insertion_point(field_get:second.protos.BootstrappedSigmoidClassificationLoss.hard_bootstrap)
  return _internal_hard_bootstrap();
}
inline void BootstrappedSigmoidClassificationLoss::_internal_set_hard_bootstrap(bool value) {
  
  _impl_.hard_bootstrap_ = value;
}
inline void BootstrappedSigmoidClassificationLoss::set_hard_bootstrap(bool value) {
  _internal_set_hard_bootstrap(value);
  // @@protoc_insertion_point(field_set:second.protos.BootstrappedSigmoidClassificationLoss.hard_bootstrap)
}

// bool anchorwise_output = 3;
inline void BootstrappedSigmoidClassificationLoss::clear_anchorwise_output() {
  _impl_.anchorwise_output_ = false;
}
inline bool BootstrappedSigmoidClassificationLoss::_internal_anchorwise_output() const {
  return _impl_.anchorwise_output_;
}
inline bool BootstrappedSigmoidClassificationLoss::anchorwise_output() const {
  // @@protoc_insertion_point(field_get:second.protos.BootstrappedSigmoidClassificationLoss.anchorwise_output)
  return _internal_anchorwise_output();
}
inline void BootstrappedSigmoidClassificationLoss::_internal_set_anchorwise_output(bool value) {
  
  _impl_.anchorwise_output_ = value;
}
inline void BootstrappedSigmoidClassificationLoss::set_anchorwise_output(bool value) {
  _internal_set_anchorwise_output(value);
  // @@protoc_insertion_point(field_set:second.protos.BootstrappedSigmoidClassificationLoss.anchorwise_output)
}

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

// HardExampleMiner

// int32 num_hard_examples = 1;
inline void HardExampleMiner::clear_num_hard_examples() {
  _impl_.num_hard_examples_ = 0;
}
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:second.protos.HardExampleMiner.num_hard_examples)
  return _internal_num_hard_examples();
}
inline void HardExampleMiner::_internal_set_num_hard_examples(int32_t value) {
  
  _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:second.protos.HardExampleMiner.num_hard_examples)
}

// float iou_threshold = 2;
inline void HardExampleMiner::clear_iou_threshold() {
  _impl_.iou_threshold_ = 0;
}
inline float HardExampleMiner::_internal_iou_threshold() const {
  return _impl_.iou_threshold_;
}
inline float HardExampleMiner::iou_threshold() const {
  // @@protoc_insertion_point(field_get:second.protos.HardExampleMiner.iou_threshold)
  return _internal_iou_threshold();
}
inline void HardExampleMiner::_internal_set_iou_threshold(float value) {
  
  _impl_.iou_threshold_ = value;
}
inline void HardExampleMiner::set_iou_threshold(float value) {
  _internal_set_iou_threshold(value);
  // @@protoc_insertion_point(field_set:second.protos.HardExampleMiner.iou_threshold)
}

// .second.protos.HardExampleMiner.LossType loss_type = 3;
inline void HardExampleMiner::clear_loss_type() {
  _impl_.loss_type_ = 0;
}
inline ::second::protos::HardExampleMiner_LossType HardExampleMiner::_internal_loss_type() const {
  return static_cast< ::second::protos::HardExampleMiner_LossType >(_impl_.loss_type_);
}
inline ::second::protos::HardExampleMiner_LossType HardExampleMiner::loss_type() const {
  // @@protoc_insertion_point(field_get:second.protos.HardExampleMiner.loss_type)
  return _internal_loss_type();
}
inline void HardExampleMiner::_internal_set_loss_type(::second::protos::HardExampleMiner_LossType value) {
  
  _impl_.loss_type_ = value;
}
inline void HardExampleMiner::set_loss_type(::second::protos::HardExampleMiner_LossType value) {
  _internal_set_loss_type(value);
  // @@protoc_insertion_point(field_set:second.protos.HardExampleMiner.loss_type)
}

// int32 max_negatives_per_positive = 4;
inline void HardExampleMiner::clear_max_negatives_per_positive() {
  _impl_.max_negatives_per_positive_ = 0;
}
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:second.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_.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:second.protos.HardExampleMiner.max_negatives_per_positive)
}

// int32 min_negatives_per_image = 5;
inline void HardExampleMiner::clear_min_negatives_per_image() {
  _impl_.min_negatives_per_image_ = 0;
}
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:second.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_.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:second.protos.HardExampleMiner.min_negatives_per_image)
}

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace second

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::second::protos::HardExampleMiner_LossType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::second::protos::HardExampleMiner_LossType>() {
  return ::second::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_second_2fprotos_2flosses_2eproto
