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

#ifndef GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2foptimizer_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2foptimizer_2eproto

#include <limits>
#include <string>

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

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_second_2fprotos_2foptimizer_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_2foptimizer_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_second_2fprotos_2foptimizer_2eproto;
namespace second {
namespace protos {
class AdamOptimizer;
struct AdamOptimizerDefaultTypeInternal;
extern AdamOptimizerDefaultTypeInternal _AdamOptimizer_default_instance_;
class ConstantLearningRate;
struct ConstantLearningRateDefaultTypeInternal;
extern ConstantLearningRateDefaultTypeInternal _ConstantLearningRate_default_instance_;
class CosineDecayLearningRate;
struct CosineDecayLearningRateDefaultTypeInternal;
extern CosineDecayLearningRateDefaultTypeInternal _CosineDecayLearningRate_default_instance_;
class ExponentialDecayLearningRate;
struct ExponentialDecayLearningRateDefaultTypeInternal;
extern ExponentialDecayLearningRateDefaultTypeInternal _ExponentialDecayLearningRate_default_instance_;
class LearningRate;
struct LearningRateDefaultTypeInternal;
extern LearningRateDefaultTypeInternal _LearningRate_default_instance_;
class ManualStepLearningRate;
struct ManualStepLearningRateDefaultTypeInternal;
extern ManualStepLearningRateDefaultTypeInternal _ManualStepLearningRate_default_instance_;
class ManualStepLearningRate_LearningRateSchedule;
struct ManualStepLearningRate_LearningRateScheduleDefaultTypeInternal;
extern ManualStepLearningRate_LearningRateScheduleDefaultTypeInternal _ManualStepLearningRate_LearningRateSchedule_default_instance_;
class MomentumOptimizer;
struct MomentumOptimizerDefaultTypeInternal;
extern MomentumOptimizerDefaultTypeInternal _MomentumOptimizer_default_instance_;
class Optimizer;
struct OptimizerDefaultTypeInternal;
extern OptimizerDefaultTypeInternal _Optimizer_default_instance_;
class RMSPropOptimizer;
struct RMSPropOptimizerDefaultTypeInternal;
extern RMSPropOptimizerDefaultTypeInternal _RMSPropOptimizer_default_instance_;
}  // namespace protos
}  // namespace second
PROTOBUF_NAMESPACE_OPEN
template<> ::second::protos::AdamOptimizer* Arena::CreateMaybeMessage<::second::protos::AdamOptimizer>(Arena*);
template<> ::second::protos::ConstantLearningRate* Arena::CreateMaybeMessage<::second::protos::ConstantLearningRate>(Arena*);
template<> ::second::protos::CosineDecayLearningRate* Arena::CreateMaybeMessage<::second::protos::CosineDecayLearningRate>(Arena*);
template<> ::second::protos::ExponentialDecayLearningRate* Arena::CreateMaybeMessage<::second::protos::ExponentialDecayLearningRate>(Arena*);
template<> ::second::protos::LearningRate* Arena::CreateMaybeMessage<::second::protos::LearningRate>(Arena*);
template<> ::second::protos::ManualStepLearningRate* Arena::CreateMaybeMessage<::second::protos::ManualStepLearningRate>(Arena*);
template<> ::second::protos::ManualStepLearningRate_LearningRateSchedule* Arena::CreateMaybeMessage<::second::protos::ManualStepLearningRate_LearningRateSchedule>(Arena*);
template<> ::second::protos::MomentumOptimizer* Arena::CreateMaybeMessage<::second::protos::MomentumOptimizer>(Arena*);
template<> ::second::protos::Optimizer* Arena::CreateMaybeMessage<::second::protos::Optimizer>(Arena*);
template<> ::second::protos::RMSPropOptimizer* Arena::CreateMaybeMessage<::second::protos::RMSPropOptimizer>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace second {
namespace protos {

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

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

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

  inline Optimizer& operator=(const Optimizer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Optimizer& operator=(Optimizer&& 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 Optimizer& default_instance() {
    return *internal_default_instance();
  }
  enum OptimizerCase {
    kRmsPropOptimizer = 1,
    kMomentumOptimizer = 2,
    kAdamOptimizer = 3,
    OPTIMIZER_NOT_SET = 0,
  };

  static inline const Optimizer* internal_default_instance() {
    return reinterpret_cast<const Optimizer*>(
               &_Optimizer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.Optimizer";
  }
  protected:
  explicit Optimizer(::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 {
    kUseMovingAverageFieldNumber = 4,
    kMovingAverageDecayFieldNumber = 5,
    kRmsPropOptimizerFieldNumber = 1,
    kMomentumOptimizerFieldNumber = 2,
    kAdamOptimizerFieldNumber = 3,
  };
  // bool use_moving_average = 4;
  void clear_use_moving_average();
  bool use_moving_average() const;
  void set_use_moving_average(bool value);
  private:
  bool _internal_use_moving_average() const;
  void _internal_set_use_moving_average(bool value);
  public:

  // float moving_average_decay = 5;
  void clear_moving_average_decay();
  float moving_average_decay() const;
  void set_moving_average_decay(float value);
  private:
  float _internal_moving_average_decay() const;
  void _internal_set_moving_average_decay(float value);
  public:

  // .second.protos.RMSPropOptimizer rms_prop_optimizer = 1;
  bool has_rms_prop_optimizer() const;
  private:
  bool _internal_has_rms_prop_optimizer() const;
  public:
  void clear_rms_prop_optimizer();
  const ::second::protos::RMSPropOptimizer& rms_prop_optimizer() const;
  PROTOBUF_NODISCARD ::second::protos::RMSPropOptimizer* release_rms_prop_optimizer();
  ::second::protos::RMSPropOptimizer* mutable_rms_prop_optimizer();
  void set_allocated_rms_prop_optimizer(::second::protos::RMSPropOptimizer* rms_prop_optimizer);
  private:
  const ::second::protos::RMSPropOptimizer& _internal_rms_prop_optimizer() const;
  ::second::protos::RMSPropOptimizer* _internal_mutable_rms_prop_optimizer();
  public:
  void unsafe_arena_set_allocated_rms_prop_optimizer(
      ::second::protos::RMSPropOptimizer* rms_prop_optimizer);
  ::second::protos::RMSPropOptimizer* unsafe_arena_release_rms_prop_optimizer();

  // .second.protos.MomentumOptimizer momentum_optimizer = 2;
  bool has_momentum_optimizer() const;
  private:
  bool _internal_has_momentum_optimizer() const;
  public:
  void clear_momentum_optimizer();
  const ::second::protos::MomentumOptimizer& momentum_optimizer() const;
  PROTOBUF_NODISCARD ::second::protos::MomentumOptimizer* release_momentum_optimizer();
  ::second::protos::MomentumOptimizer* mutable_momentum_optimizer();
  void set_allocated_momentum_optimizer(::second::protos::MomentumOptimizer* momentum_optimizer);
  private:
  const ::second::protos::MomentumOptimizer& _internal_momentum_optimizer() const;
  ::second::protos::MomentumOptimizer* _internal_mutable_momentum_optimizer();
  public:
  void unsafe_arena_set_allocated_momentum_optimizer(
      ::second::protos::MomentumOptimizer* momentum_optimizer);
  ::second::protos::MomentumOptimizer* unsafe_arena_release_momentum_optimizer();

  // .second.protos.AdamOptimizer adam_optimizer = 3;
  bool has_adam_optimizer() const;
  private:
  bool _internal_has_adam_optimizer() const;
  public:
  void clear_adam_optimizer();
  const ::second::protos::AdamOptimizer& adam_optimizer() const;
  PROTOBUF_NODISCARD ::second::protos::AdamOptimizer* release_adam_optimizer();
  ::second::protos::AdamOptimizer* mutable_adam_optimizer();
  void set_allocated_adam_optimizer(::second::protos::AdamOptimizer* adam_optimizer);
  private:
  const ::second::protos::AdamOptimizer& _internal_adam_optimizer() const;
  ::second::protos::AdamOptimizer* _internal_mutable_adam_optimizer();
  public:
  void unsafe_arena_set_allocated_adam_optimizer(
      ::second::protos::AdamOptimizer* adam_optimizer);
  ::second::protos::AdamOptimizer* unsafe_arena_release_adam_optimizer();

  void clear_optimizer();
  OptimizerCase optimizer_case() const;
  // @@protoc_insertion_point(class_scope:second.protos.Optimizer)
 private:
  class _Internal;
  void set_has_rms_prop_optimizer();
  void set_has_momentum_optimizer();
  void set_has_adam_optimizer();

  inline bool has_optimizer() const;
  inline void clear_has_optimizer();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    bool use_moving_average_;
    float moving_average_decay_;
    union OptimizerUnion {
      constexpr OptimizerUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::second::protos::RMSPropOptimizer* rms_prop_optimizer_;
      ::second::protos::MomentumOptimizer* momentum_optimizer_;
      ::second::protos::AdamOptimizer* adam_optimizer_;
    } optimizer_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.RMSPropOptimizer";
  }
  protected:
  explicit RMSPropOptimizer(::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 {
    kLearningRateFieldNumber = 1,
    kMomentumOptimizerValueFieldNumber = 2,
    kDecayFieldNumber = 3,
    kEpsilonFieldNumber = 4,
    kWeightDecayFieldNumber = 5,
  };
  // .second.protos.LearningRate learning_rate = 1;
  bool has_learning_rate() const;
  private:
  bool _internal_has_learning_rate() const;
  public:
  void clear_learning_rate();
  const ::second::protos::LearningRate& learning_rate() const;
  PROTOBUF_NODISCARD ::second::protos::LearningRate* release_learning_rate();
  ::second::protos::LearningRate* mutable_learning_rate();
  void set_allocated_learning_rate(::second::protos::LearningRate* learning_rate);
  private:
  const ::second::protos::LearningRate& _internal_learning_rate() const;
  ::second::protos::LearningRate* _internal_mutable_learning_rate();
  public:
  void unsafe_arena_set_allocated_learning_rate(
      ::second::protos::LearningRate* learning_rate);
  ::second::protos::LearningRate* unsafe_arena_release_learning_rate();

  // float momentum_optimizer_value = 2;
  void clear_momentum_optimizer_value();
  float momentum_optimizer_value() const;
  void set_momentum_optimizer_value(float value);
  private:
  float _internal_momentum_optimizer_value() const;
  void _internal_set_momentum_optimizer_value(float value);
  public:

  // float decay = 3;
  void clear_decay();
  float decay() const;
  void set_decay(float value);
  private:
  float _internal_decay() const;
  void _internal_set_decay(float value);
  public:

  // float epsilon = 4;
  void clear_epsilon();
  float epsilon() const;
  void set_epsilon(float value);
  private:
  float _internal_epsilon() const;
  void _internal_set_epsilon(float value);
  public:

  // float weight_decay = 5;
  void clear_weight_decay();
  float weight_decay() const;
  void set_weight_decay(float value);
  private:
  float _internal_weight_decay() const;
  void _internal_set_weight_decay(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::second::protos::LearningRate* learning_rate_;
    float momentum_optimizer_value_;
    float decay_;
    float epsilon_;
    float weight_decay_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2foptimizer_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.MomentumOptimizer";
  }
  protected:
  explicit MomentumOptimizer(::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 {
    kLearningRateFieldNumber = 1,
    kMomentumOptimizerValueFieldNumber = 2,
    kWeightDecayFieldNumber = 3,
  };
  // .second.protos.LearningRate learning_rate = 1;
  bool has_learning_rate() const;
  private:
  bool _internal_has_learning_rate() const;
  public:
  void clear_learning_rate();
  const ::second::protos::LearningRate& learning_rate() const;
  PROTOBUF_NODISCARD ::second::protos::LearningRate* release_learning_rate();
  ::second::protos::LearningRate* mutable_learning_rate();
  void set_allocated_learning_rate(::second::protos::LearningRate* learning_rate);
  private:
  const ::second::protos::LearningRate& _internal_learning_rate() const;
  ::second::protos::LearningRate* _internal_mutable_learning_rate();
  public:
  void unsafe_arena_set_allocated_learning_rate(
      ::second::protos::LearningRate* learning_rate);
  ::second::protos::LearningRate* unsafe_arena_release_learning_rate();

  // float momentum_optimizer_value = 2;
  void clear_momentum_optimizer_value();
  float momentum_optimizer_value() const;
  void set_momentum_optimizer_value(float value);
  private:
  float _internal_momentum_optimizer_value() const;
  void _internal_set_momentum_optimizer_value(float value);
  public:

  // float weight_decay = 3;
  void clear_weight_decay();
  float weight_decay() const;
  void set_weight_decay(float value);
  private:
  float _internal_weight_decay() const;
  void _internal_set_weight_decay(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::second::protos::LearningRate* learning_rate_;
    float momentum_optimizer_value_;
    float weight_decay_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2foptimizer_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.AdamOptimizer";
  }
  protected:
  explicit AdamOptimizer(::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 {
    kLearningRateFieldNumber = 1,
    kWeightDecayFieldNumber = 2,
  };
  // .second.protos.LearningRate learning_rate = 1;
  bool has_learning_rate() const;
  private:
  bool _internal_has_learning_rate() const;
  public:
  void clear_learning_rate();
  const ::second::protos::LearningRate& learning_rate() const;
  PROTOBUF_NODISCARD ::second::protos::LearningRate* release_learning_rate();
  ::second::protos::LearningRate* mutable_learning_rate();
  void set_allocated_learning_rate(::second::protos::LearningRate* learning_rate);
  private:
  const ::second::protos::LearningRate& _internal_learning_rate() const;
  ::second::protos::LearningRate* _internal_mutable_learning_rate();
  public:
  void unsafe_arena_set_allocated_learning_rate(
      ::second::protos::LearningRate* learning_rate);
  ::second::protos::LearningRate* unsafe_arena_release_learning_rate();

  // float weight_decay = 2;
  void clear_weight_decay();
  float weight_decay() const;
  void set_weight_decay(float value);
  private:
  float _internal_weight_decay() const;
  void _internal_set_weight_decay(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::second::protos::LearningRate* learning_rate_;
    float weight_decay_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2foptimizer_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LearningRate& operator=(const LearningRate& from) {
    CopyFrom(from);
    return *this;
  }
  inline LearningRate& operator=(LearningRate&& 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 LearningRate& default_instance() {
    return *internal_default_instance();
  }
  enum LearningRateCase {
    kConstantLearningRate = 1,
    kExponentialDecayLearningRate = 2,
    kManualStepLearningRate = 3,
    kCosineDecayLearningRate = 4,
    LEARNING_RATE_NOT_SET = 0,
  };

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.LearningRate";
  }
  protected:
  explicit LearningRate(::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 {
    kConstantLearningRateFieldNumber = 1,
    kExponentialDecayLearningRateFieldNumber = 2,
    kManualStepLearningRateFieldNumber = 3,
    kCosineDecayLearningRateFieldNumber = 4,
  };
  // .second.protos.ConstantLearningRate constant_learning_rate = 1;
  bool has_constant_learning_rate() const;
  private:
  bool _internal_has_constant_learning_rate() const;
  public:
  void clear_constant_learning_rate();
  const ::second::protos::ConstantLearningRate& constant_learning_rate() const;
  PROTOBUF_NODISCARD ::second::protos::ConstantLearningRate* release_constant_learning_rate();
  ::second::protos::ConstantLearningRate* mutable_constant_learning_rate();
  void set_allocated_constant_learning_rate(::second::protos::ConstantLearningRate* constant_learning_rate);
  private:
  const ::second::protos::ConstantLearningRate& _internal_constant_learning_rate() const;
  ::second::protos::ConstantLearningRate* _internal_mutable_constant_learning_rate();
  public:
  void unsafe_arena_set_allocated_constant_learning_rate(
      ::second::protos::ConstantLearningRate* constant_learning_rate);
  ::second::protos::ConstantLearningRate* unsafe_arena_release_constant_learning_rate();

  // .second.protos.ExponentialDecayLearningRate exponential_decay_learning_rate = 2;
  bool has_exponential_decay_learning_rate() const;
  private:
  bool _internal_has_exponential_decay_learning_rate() const;
  public:
  void clear_exponential_decay_learning_rate();
  const ::second::protos::ExponentialDecayLearningRate& exponential_decay_learning_rate() const;
  PROTOBUF_NODISCARD ::second::protos::ExponentialDecayLearningRate* release_exponential_decay_learning_rate();
  ::second::protos::ExponentialDecayLearningRate* mutable_exponential_decay_learning_rate();
  void set_allocated_exponential_decay_learning_rate(::second::protos::ExponentialDecayLearningRate* exponential_decay_learning_rate);
  private:
  const ::second::protos::ExponentialDecayLearningRate& _internal_exponential_decay_learning_rate() const;
  ::second::protos::ExponentialDecayLearningRate* _internal_mutable_exponential_decay_learning_rate();
  public:
  void unsafe_arena_set_allocated_exponential_decay_learning_rate(
      ::second::protos::ExponentialDecayLearningRate* exponential_decay_learning_rate);
  ::second::protos::ExponentialDecayLearningRate* unsafe_arena_release_exponential_decay_learning_rate();

  // .second.protos.ManualStepLearningRate manual_step_learning_rate = 3;
  bool has_manual_step_learning_rate() const;
  private:
  bool _internal_has_manual_step_learning_rate() const;
  public:
  void clear_manual_step_learning_rate();
  const ::second::protos::ManualStepLearningRate& manual_step_learning_rate() const;
  PROTOBUF_NODISCARD ::second::protos::ManualStepLearningRate* release_manual_step_learning_rate();
  ::second::protos::ManualStepLearningRate* mutable_manual_step_learning_rate();
  void set_allocated_manual_step_learning_rate(::second::protos::ManualStepLearningRate* manual_step_learning_rate);
  private:
  const ::second::protos::ManualStepLearningRate& _internal_manual_step_learning_rate() const;
  ::second::protos::ManualStepLearningRate* _internal_mutable_manual_step_learning_rate();
  public:
  void unsafe_arena_set_allocated_manual_step_learning_rate(
      ::second::protos::ManualStepLearningRate* manual_step_learning_rate);
  ::second::protos::ManualStepLearningRate* unsafe_arena_release_manual_step_learning_rate();

  // .second.protos.CosineDecayLearningRate cosine_decay_learning_rate = 4;
  bool has_cosine_decay_learning_rate() const;
  private:
  bool _internal_has_cosine_decay_learning_rate() const;
  public:
  void clear_cosine_decay_learning_rate();
  const ::second::protos::CosineDecayLearningRate& cosine_decay_learning_rate() const;
  PROTOBUF_NODISCARD ::second::protos::CosineDecayLearningRate* release_cosine_decay_learning_rate();
  ::second::protos::CosineDecayLearningRate* mutable_cosine_decay_learning_rate();
  void set_allocated_cosine_decay_learning_rate(::second::protos::CosineDecayLearningRate* cosine_decay_learning_rate);
  private:
  const ::second::protos::CosineDecayLearningRate& _internal_cosine_decay_learning_rate() const;
  ::second::protos::CosineDecayLearningRate* _internal_mutable_cosine_decay_learning_rate();
  public:
  void unsafe_arena_set_allocated_cosine_decay_learning_rate(
      ::second::protos::CosineDecayLearningRate* cosine_decay_learning_rate);
  ::second::protos::CosineDecayLearningRate* unsafe_arena_release_cosine_decay_learning_rate();

  void clear_learning_rate();
  LearningRateCase learning_rate_case() const;
  // @@protoc_insertion_point(class_scope:second.protos.LearningRate)
 private:
  class _Internal;
  void set_has_constant_learning_rate();
  void set_has_exponential_decay_learning_rate();
  void set_has_manual_step_learning_rate();
  void set_has_cosine_decay_learning_rate();

  inline bool has_learning_rate() const;
  inline void clear_has_learning_rate();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union LearningRateUnion {
      constexpr LearningRateUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::second::protos::ConstantLearningRate* constant_learning_rate_;
      ::second::protos::ExponentialDecayLearningRate* exponential_decay_learning_rate_;
      ::second::protos::ManualStepLearningRate* manual_step_learning_rate_;
      ::second::protos::CosineDecayLearningRate* cosine_decay_learning_rate_;
    } learning_rate_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.ConstantLearningRate";
  }
  protected:
  explicit ConstantLearningRate(::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 {
    kLearningRateFieldNumber = 1,
  };
  // float learning_rate = 1;
  void clear_learning_rate();
  float learning_rate() const;
  void set_learning_rate(float value);
  private:
  float _internal_learning_rate() const;
  void _internal_set_learning_rate(float value);
  public:

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

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.ExponentialDecayLearningRate";
  }
  protected:
  explicit ExponentialDecayLearningRate(::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 {
    kInitialLearningRateFieldNumber = 1,
    kDecayStepsFieldNumber = 2,
    kDecayFactorFieldNumber = 3,
    kStaircaseFieldNumber = 4,
  };
  // float initial_learning_rate = 1;
  void clear_initial_learning_rate();
  float initial_learning_rate() const;
  void set_initial_learning_rate(float value);
  private:
  float _internal_initial_learning_rate() const;
  void _internal_set_initial_learning_rate(float value);
  public:

  // uint32 decay_steps = 2;
  void clear_decay_steps();
  uint32_t decay_steps() const;
  void set_decay_steps(uint32_t value);
  private:
  uint32_t _internal_decay_steps() const;
  void _internal_set_decay_steps(uint32_t value);
  public:

  // float decay_factor = 3;
  void clear_decay_factor();
  float decay_factor() const;
  void set_decay_factor(float value);
  private:
  float _internal_decay_factor() const;
  void _internal_set_decay_factor(float value);
  public:

  // bool staircase = 4;
  void clear_staircase();
  bool staircase() const;
  void set_staircase(bool value);
  private:
  bool _internal_staircase() const;
  void _internal_set_staircase(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    float initial_learning_rate_;
    uint32_t decay_steps_;
    float decay_factor_;
    bool staircase_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2foptimizer_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.ManualStepLearningRate.LearningRateSchedule";
  }
  protected:
  explicit ManualStepLearningRate_LearningRateSchedule(::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 {
    kStepFieldNumber = 1,
    kLearningRateFieldNumber = 2,
  };
  // uint32 step = 1;
  void clear_step();
  uint32_t step() const;
  void set_step(uint32_t value);
  private:
  uint32_t _internal_step() const;
  void _internal_set_step(uint32_t value);
  public:

  // float learning_rate = 2;
  void clear_learning_rate();
  float learning_rate() const;
  void set_learning_rate(float value);
  private:
  float _internal_learning_rate() const;
  void _internal_set_learning_rate(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint32_t step_;
    float learning_rate_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2foptimizer_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.ManualStepLearningRate";
  }
  protected:
  explicit ManualStepLearningRate(::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 ManualStepLearningRate_LearningRateSchedule LearningRateSchedule;

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

  enum : int {
    kScheduleFieldNumber = 2,
    kInitialLearningRateFieldNumber = 1,
  };
  // repeated .second.protos.ManualStepLearningRate.LearningRateSchedule schedule = 2;
  int schedule_size() const;
  private:
  int _internal_schedule_size() const;
  public:
  void clear_schedule();
  ::second::protos::ManualStepLearningRate_LearningRateSchedule* mutable_schedule(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::second::protos::ManualStepLearningRate_LearningRateSchedule >*
      mutable_schedule();
  private:
  const ::second::protos::ManualStepLearningRate_LearningRateSchedule& _internal_schedule(int index) const;
  ::second::protos::ManualStepLearningRate_LearningRateSchedule* _internal_add_schedule();
  public:
  const ::second::protos::ManualStepLearningRate_LearningRateSchedule& schedule(int index) const;
  ::second::protos::ManualStepLearningRate_LearningRateSchedule* add_schedule();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::second::protos::ManualStepLearningRate_LearningRateSchedule >&
      schedule() const;

  // float initial_learning_rate = 1;
  void clear_initial_learning_rate();
  float initial_learning_rate() const;
  void set_initial_learning_rate(float value);
  private:
  float _internal_initial_learning_rate() const;
  void _internal_set_initial_learning_rate(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::second::protos::ManualStepLearningRate_LearningRateSchedule > schedule_;
    float initial_learning_rate_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2foptimizer_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.CosineDecayLearningRate";
  }
  protected:
  explicit CosineDecayLearningRate(::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 {
    kLearningRateBaseFieldNumber = 1,
    kTotalStepsFieldNumber = 2,
    kWarmupLearningRateFieldNumber = 3,
    kWarmupStepsFieldNumber = 4,
  };
  // float learning_rate_base = 1;
  void clear_learning_rate_base();
  float learning_rate_base() const;
  void set_learning_rate_base(float value);
  private:
  float _internal_learning_rate_base() const;
  void _internal_set_learning_rate_base(float value);
  public:

  // uint32 total_steps = 2;
  void clear_total_steps();
  uint32_t total_steps() const;
  void set_total_steps(uint32_t value);
  private:
  uint32_t _internal_total_steps() const;
  void _internal_set_total_steps(uint32_t value);
  public:

  // float warmup_learning_rate = 3;
  void clear_warmup_learning_rate();
  float warmup_learning_rate() const;
  void set_warmup_learning_rate(float value);
  private:
  float _internal_warmup_learning_rate() const;
  void _internal_set_warmup_learning_rate(float value);
  public:

  // uint32 warmup_steps = 4;
  void clear_warmup_steps();
  uint32_t warmup_steps() const;
  void set_warmup_steps(uint32_t value);
  private:
  uint32_t _internal_warmup_steps() const;
  void _internal_set_warmup_steps(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    float learning_rate_base_;
    uint32_t total_steps_;
    float warmup_learning_rate_;
    uint32_t warmup_steps_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2foptimizer_2eproto;
};
// ===================================================================


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

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

// .second.protos.RMSPropOptimizer rms_prop_optimizer = 1;
inline bool Optimizer::_internal_has_rms_prop_optimizer() const {
  return optimizer_case() == kRmsPropOptimizer;
}
inline bool Optimizer::has_rms_prop_optimizer() const {
  return _internal_has_rms_prop_optimizer();
}
inline void Optimizer::set_has_rms_prop_optimizer() {
  _impl_._oneof_case_[0] = kRmsPropOptimizer;
}
inline void Optimizer::clear_rms_prop_optimizer() {
  if (_internal_has_rms_prop_optimizer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.optimizer_.rms_prop_optimizer_;
    }
    clear_has_optimizer();
  }
}
inline ::second::protos::RMSPropOptimizer* Optimizer::release_rms_prop_optimizer() {
  // @@protoc_insertion_point(field_release:second.protos.Optimizer.rms_prop_optimizer)
  if (_internal_has_rms_prop_optimizer()) {
    clear_has_optimizer();
    ::second::protos::RMSPropOptimizer* temp = _impl_.optimizer_.rms_prop_optimizer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.optimizer_.rms_prop_optimizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::RMSPropOptimizer& Optimizer::_internal_rms_prop_optimizer() const {
  return _internal_has_rms_prop_optimizer()
      ? *_impl_.optimizer_.rms_prop_optimizer_
      : reinterpret_cast< ::second::protos::RMSPropOptimizer&>(::second::protos::_RMSPropOptimizer_default_instance_);
}
inline const ::second::protos::RMSPropOptimizer& Optimizer::rms_prop_optimizer() const {
  // @@protoc_insertion_point(field_get:second.protos.Optimizer.rms_prop_optimizer)
  return _internal_rms_prop_optimizer();
}
inline ::second::protos::RMSPropOptimizer* Optimizer::unsafe_arena_release_rms_prop_optimizer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Optimizer.rms_prop_optimizer)
  if (_internal_has_rms_prop_optimizer()) {
    clear_has_optimizer();
    ::second::protos::RMSPropOptimizer* temp = _impl_.optimizer_.rms_prop_optimizer_;
    _impl_.optimizer_.rms_prop_optimizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Optimizer::unsafe_arena_set_allocated_rms_prop_optimizer(::second::protos::RMSPropOptimizer* rms_prop_optimizer) {
  clear_optimizer();
  if (rms_prop_optimizer) {
    set_has_rms_prop_optimizer();
    _impl_.optimizer_.rms_prop_optimizer_ = rms_prop_optimizer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Optimizer.rms_prop_optimizer)
}
inline ::second::protos::RMSPropOptimizer* Optimizer::_internal_mutable_rms_prop_optimizer() {
  if (!_internal_has_rms_prop_optimizer()) {
    clear_optimizer();
    set_has_rms_prop_optimizer();
    _impl_.optimizer_.rms_prop_optimizer_ = CreateMaybeMessage< ::second::protos::RMSPropOptimizer >(GetArenaForAllocation());
  }
  return _impl_.optimizer_.rms_prop_optimizer_;
}
inline ::second::protos::RMSPropOptimizer* Optimizer::mutable_rms_prop_optimizer() {
  ::second::protos::RMSPropOptimizer* _msg = _internal_mutable_rms_prop_optimizer();
  // @@protoc_insertion_point(field_mutable:second.protos.Optimizer.rms_prop_optimizer)
  return _msg;
}

// .second.protos.MomentumOptimizer momentum_optimizer = 2;
inline bool Optimizer::_internal_has_momentum_optimizer() const {
  return optimizer_case() == kMomentumOptimizer;
}
inline bool Optimizer::has_momentum_optimizer() const {
  return _internal_has_momentum_optimizer();
}
inline void Optimizer::set_has_momentum_optimizer() {
  _impl_._oneof_case_[0] = kMomentumOptimizer;
}
inline void Optimizer::clear_momentum_optimizer() {
  if (_internal_has_momentum_optimizer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.optimizer_.momentum_optimizer_;
    }
    clear_has_optimizer();
  }
}
inline ::second::protos::MomentumOptimizer* Optimizer::release_momentum_optimizer() {
  // @@protoc_insertion_point(field_release:second.protos.Optimizer.momentum_optimizer)
  if (_internal_has_momentum_optimizer()) {
    clear_has_optimizer();
    ::second::protos::MomentumOptimizer* temp = _impl_.optimizer_.momentum_optimizer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.optimizer_.momentum_optimizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::MomentumOptimizer& Optimizer::_internal_momentum_optimizer() const {
  return _internal_has_momentum_optimizer()
      ? *_impl_.optimizer_.momentum_optimizer_
      : reinterpret_cast< ::second::protos::MomentumOptimizer&>(::second::protos::_MomentumOptimizer_default_instance_);
}
inline const ::second::protos::MomentumOptimizer& Optimizer::momentum_optimizer() const {
  // @@protoc_insertion_point(field_get:second.protos.Optimizer.momentum_optimizer)
  return _internal_momentum_optimizer();
}
inline ::second::protos::MomentumOptimizer* Optimizer::unsafe_arena_release_momentum_optimizer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Optimizer.momentum_optimizer)
  if (_internal_has_momentum_optimizer()) {
    clear_has_optimizer();
    ::second::protos::MomentumOptimizer* temp = _impl_.optimizer_.momentum_optimizer_;
    _impl_.optimizer_.momentum_optimizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Optimizer::unsafe_arena_set_allocated_momentum_optimizer(::second::protos::MomentumOptimizer* momentum_optimizer) {
  clear_optimizer();
  if (momentum_optimizer) {
    set_has_momentum_optimizer();
    _impl_.optimizer_.momentum_optimizer_ = momentum_optimizer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Optimizer.momentum_optimizer)
}
inline ::second::protos::MomentumOptimizer* Optimizer::_internal_mutable_momentum_optimizer() {
  if (!_internal_has_momentum_optimizer()) {
    clear_optimizer();
    set_has_momentum_optimizer();
    _impl_.optimizer_.momentum_optimizer_ = CreateMaybeMessage< ::second::protos::MomentumOptimizer >(GetArenaForAllocation());
  }
  return _impl_.optimizer_.momentum_optimizer_;
}
inline ::second::protos::MomentumOptimizer* Optimizer::mutable_momentum_optimizer() {
  ::second::protos::MomentumOptimizer* _msg = _internal_mutable_momentum_optimizer();
  // @@protoc_insertion_point(field_mutable:second.protos.Optimizer.momentum_optimizer)
  return _msg;
}

// .second.protos.AdamOptimizer adam_optimizer = 3;
inline bool Optimizer::_internal_has_adam_optimizer() const {
  return optimizer_case() == kAdamOptimizer;
}
inline bool Optimizer::has_adam_optimizer() const {
  return _internal_has_adam_optimizer();
}
inline void Optimizer::set_has_adam_optimizer() {
  _impl_._oneof_case_[0] = kAdamOptimizer;
}
inline void Optimizer::clear_adam_optimizer() {
  if (_internal_has_adam_optimizer()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.optimizer_.adam_optimizer_;
    }
    clear_has_optimizer();
  }
}
inline ::second::protos::AdamOptimizer* Optimizer::release_adam_optimizer() {
  // @@protoc_insertion_point(field_release:second.protos.Optimizer.adam_optimizer)
  if (_internal_has_adam_optimizer()) {
    clear_has_optimizer();
    ::second::protos::AdamOptimizer* temp = _impl_.optimizer_.adam_optimizer_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.optimizer_.adam_optimizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::AdamOptimizer& Optimizer::_internal_adam_optimizer() const {
  return _internal_has_adam_optimizer()
      ? *_impl_.optimizer_.adam_optimizer_
      : reinterpret_cast< ::second::protos::AdamOptimizer&>(::second::protos::_AdamOptimizer_default_instance_);
}
inline const ::second::protos::AdamOptimizer& Optimizer::adam_optimizer() const {
  // @@protoc_insertion_point(field_get:second.protos.Optimizer.adam_optimizer)
  return _internal_adam_optimizer();
}
inline ::second::protos::AdamOptimizer* Optimizer::unsafe_arena_release_adam_optimizer() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Optimizer.adam_optimizer)
  if (_internal_has_adam_optimizer()) {
    clear_has_optimizer();
    ::second::protos::AdamOptimizer* temp = _impl_.optimizer_.adam_optimizer_;
    _impl_.optimizer_.adam_optimizer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Optimizer::unsafe_arena_set_allocated_adam_optimizer(::second::protos::AdamOptimizer* adam_optimizer) {
  clear_optimizer();
  if (adam_optimizer) {
    set_has_adam_optimizer();
    _impl_.optimizer_.adam_optimizer_ = adam_optimizer;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Optimizer.adam_optimizer)
}
inline ::second::protos::AdamOptimizer* Optimizer::_internal_mutable_adam_optimizer() {
  if (!_internal_has_adam_optimizer()) {
    clear_optimizer();
    set_has_adam_optimizer();
    _impl_.optimizer_.adam_optimizer_ = CreateMaybeMessage< ::second::protos::AdamOptimizer >(GetArenaForAllocation());
  }
  return _impl_.optimizer_.adam_optimizer_;
}
inline ::second::protos::AdamOptimizer* Optimizer::mutable_adam_optimizer() {
  ::second::protos::AdamOptimizer* _msg = _internal_mutable_adam_optimizer();
  // @@protoc_insertion_point(field_mutable:second.protos.Optimizer.adam_optimizer)
  return _msg;
}

// bool use_moving_average = 4;
inline void Optimizer::clear_use_moving_average() {
  _impl_.use_moving_average_ = false;
}
inline bool Optimizer::_internal_use_moving_average() const {
  return _impl_.use_moving_average_;
}
inline bool Optimizer::use_moving_average() const {
  // @@protoc_insertion_point(field_get:second.protos.Optimizer.use_moving_average)
  return _internal_use_moving_average();
}
inline void Optimizer::_internal_set_use_moving_average(bool value) {
  
  _impl_.use_moving_average_ = value;
}
inline void Optimizer::set_use_moving_average(bool value) {
  _internal_set_use_moving_average(value);
  // @@protoc_insertion_point(field_set:second.protos.Optimizer.use_moving_average)
}

// float moving_average_decay = 5;
inline void Optimizer::clear_moving_average_decay() {
  _impl_.moving_average_decay_ = 0;
}
inline float Optimizer::_internal_moving_average_decay() const {
  return _impl_.moving_average_decay_;
}
inline float Optimizer::moving_average_decay() const {
  // @@protoc_insertion_point(field_get:second.protos.Optimizer.moving_average_decay)
  return _internal_moving_average_decay();
}
inline void Optimizer::_internal_set_moving_average_decay(float value) {
  
  _impl_.moving_average_decay_ = value;
}
inline void Optimizer::set_moving_average_decay(float value) {
  _internal_set_moving_average_decay(value);
  // @@protoc_insertion_point(field_set:second.protos.Optimizer.moving_average_decay)
}

inline bool Optimizer::has_optimizer() const {
  return optimizer_case() != OPTIMIZER_NOT_SET;
}
inline void Optimizer::clear_has_optimizer() {
  _impl_._oneof_case_[0] = OPTIMIZER_NOT_SET;
}
inline Optimizer::OptimizerCase Optimizer::optimizer_case() const {
  return Optimizer::OptimizerCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// RMSPropOptimizer

// .second.protos.LearningRate learning_rate = 1;
inline bool RMSPropOptimizer::_internal_has_learning_rate() const {
  return this != internal_default_instance() && _impl_.learning_rate_ != nullptr;
}
inline bool RMSPropOptimizer::has_learning_rate() const {
  return _internal_has_learning_rate();
}
inline void RMSPropOptimizer::clear_learning_rate() {
  if (GetArenaForAllocation() == nullptr && _impl_.learning_rate_ != nullptr) {
    delete _impl_.learning_rate_;
  }
  _impl_.learning_rate_ = nullptr;
}
inline const ::second::protos::LearningRate& RMSPropOptimizer::_internal_learning_rate() const {
  const ::second::protos::LearningRate* p = _impl_.learning_rate_;
  return p != nullptr ? *p : reinterpret_cast<const ::second::protos::LearningRate&>(
      ::second::protos::_LearningRate_default_instance_);
}
inline const ::second::protos::LearningRate& RMSPropOptimizer::learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.RMSPropOptimizer.learning_rate)
  return _internal_learning_rate();
}
inline void RMSPropOptimizer::unsafe_arena_set_allocated_learning_rate(
    ::second::protos::LearningRate* learning_rate) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.learning_rate_);
  }
  _impl_.learning_rate_ = learning_rate;
  if (learning_rate) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.RMSPropOptimizer.learning_rate)
}
inline ::second::protos::LearningRate* RMSPropOptimizer::release_learning_rate() {
  
  ::second::protos::LearningRate* temp = _impl_.learning_rate_;
  _impl_.learning_rate_ = 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::LearningRate* RMSPropOptimizer::unsafe_arena_release_learning_rate() {
  // @@protoc_insertion_point(field_release:second.protos.RMSPropOptimizer.learning_rate)
  
  ::second::protos::LearningRate* temp = _impl_.learning_rate_;
  _impl_.learning_rate_ = nullptr;
  return temp;
}
inline ::second::protos::LearningRate* RMSPropOptimizer::_internal_mutable_learning_rate() {
  
  if (_impl_.learning_rate_ == nullptr) {
    auto* p = CreateMaybeMessage<::second::protos::LearningRate>(GetArenaForAllocation());
    _impl_.learning_rate_ = p;
  }
  return _impl_.learning_rate_;
}
inline ::second::protos::LearningRate* RMSPropOptimizer::mutable_learning_rate() {
  ::second::protos::LearningRate* _msg = _internal_mutable_learning_rate();
  // @@protoc_insertion_point(field_mutable:second.protos.RMSPropOptimizer.learning_rate)
  return _msg;
}
inline void RMSPropOptimizer::set_allocated_learning_rate(::second::protos::LearningRate* learning_rate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.learning_rate_;
  }
  if (learning_rate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(learning_rate);
    if (message_arena != submessage_arena) {
      learning_rate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, learning_rate, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.learning_rate_ = learning_rate;
  // @@protoc_insertion_point(field_set_allocated:second.protos.RMSPropOptimizer.learning_rate)
}

// float momentum_optimizer_value = 2;
inline void RMSPropOptimizer::clear_momentum_optimizer_value() {
  _impl_.momentum_optimizer_value_ = 0;
}
inline float RMSPropOptimizer::_internal_momentum_optimizer_value() const {
  return _impl_.momentum_optimizer_value_;
}
inline float RMSPropOptimizer::momentum_optimizer_value() const {
  // @@protoc_insertion_point(field_get:second.protos.RMSPropOptimizer.momentum_optimizer_value)
  return _internal_momentum_optimizer_value();
}
inline void RMSPropOptimizer::_internal_set_momentum_optimizer_value(float value) {
  
  _impl_.momentum_optimizer_value_ = value;
}
inline void RMSPropOptimizer::set_momentum_optimizer_value(float value) {
  _internal_set_momentum_optimizer_value(value);
  // @@protoc_insertion_point(field_set:second.protos.RMSPropOptimizer.momentum_optimizer_value)
}

// float decay = 3;
inline void RMSPropOptimizer::clear_decay() {
  _impl_.decay_ = 0;
}
inline float RMSPropOptimizer::_internal_decay() const {
  return _impl_.decay_;
}
inline float RMSPropOptimizer::decay() const {
  // @@protoc_insertion_point(field_get:second.protos.RMSPropOptimizer.decay)
  return _internal_decay();
}
inline void RMSPropOptimizer::_internal_set_decay(float value) {
  
  _impl_.decay_ = value;
}
inline void RMSPropOptimizer::set_decay(float value) {
  _internal_set_decay(value);
  // @@protoc_insertion_point(field_set:second.protos.RMSPropOptimizer.decay)
}

// float epsilon = 4;
inline void RMSPropOptimizer::clear_epsilon() {
  _impl_.epsilon_ = 0;
}
inline float RMSPropOptimizer::_internal_epsilon() const {
  return _impl_.epsilon_;
}
inline float RMSPropOptimizer::epsilon() const {
  // @@protoc_insertion_point(field_get:second.protos.RMSPropOptimizer.epsilon)
  return _internal_epsilon();
}
inline void RMSPropOptimizer::_internal_set_epsilon(float value) {
  
  _impl_.epsilon_ = value;
}
inline void RMSPropOptimizer::set_epsilon(float value) {
  _internal_set_epsilon(value);
  // @@protoc_insertion_point(field_set:second.protos.RMSPropOptimizer.epsilon)
}

// float weight_decay = 5;
inline void RMSPropOptimizer::clear_weight_decay() {
  _impl_.weight_decay_ = 0;
}
inline float RMSPropOptimizer::_internal_weight_decay() const {
  return _impl_.weight_decay_;
}
inline float RMSPropOptimizer::weight_decay() const {
  // @@protoc_insertion_point(field_get:second.protos.RMSPropOptimizer.weight_decay)
  return _internal_weight_decay();
}
inline void RMSPropOptimizer::_internal_set_weight_decay(float value) {
  
  _impl_.weight_decay_ = value;
}
inline void RMSPropOptimizer::set_weight_decay(float value) {
  _internal_set_weight_decay(value);
  // @@protoc_insertion_point(field_set:second.protos.RMSPropOptimizer.weight_decay)
}

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

// MomentumOptimizer

// .second.protos.LearningRate learning_rate = 1;
inline bool MomentumOptimizer::_internal_has_learning_rate() const {
  return this != internal_default_instance() && _impl_.learning_rate_ != nullptr;
}
inline bool MomentumOptimizer::has_learning_rate() const {
  return _internal_has_learning_rate();
}
inline void MomentumOptimizer::clear_learning_rate() {
  if (GetArenaForAllocation() == nullptr && _impl_.learning_rate_ != nullptr) {
    delete _impl_.learning_rate_;
  }
  _impl_.learning_rate_ = nullptr;
}
inline const ::second::protos::LearningRate& MomentumOptimizer::_internal_learning_rate() const {
  const ::second::protos::LearningRate* p = _impl_.learning_rate_;
  return p != nullptr ? *p : reinterpret_cast<const ::second::protos::LearningRate&>(
      ::second::protos::_LearningRate_default_instance_);
}
inline const ::second::protos::LearningRate& MomentumOptimizer::learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.MomentumOptimizer.learning_rate)
  return _internal_learning_rate();
}
inline void MomentumOptimizer::unsafe_arena_set_allocated_learning_rate(
    ::second::protos::LearningRate* learning_rate) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.learning_rate_);
  }
  _impl_.learning_rate_ = learning_rate;
  if (learning_rate) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.MomentumOptimizer.learning_rate)
}
inline ::second::protos::LearningRate* MomentumOptimizer::release_learning_rate() {
  
  ::second::protos::LearningRate* temp = _impl_.learning_rate_;
  _impl_.learning_rate_ = 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::LearningRate* MomentumOptimizer::unsafe_arena_release_learning_rate() {
  // @@protoc_insertion_point(field_release:second.protos.MomentumOptimizer.learning_rate)
  
  ::second::protos::LearningRate* temp = _impl_.learning_rate_;
  _impl_.learning_rate_ = nullptr;
  return temp;
}
inline ::second::protos::LearningRate* MomentumOptimizer::_internal_mutable_learning_rate() {
  
  if (_impl_.learning_rate_ == nullptr) {
    auto* p = CreateMaybeMessage<::second::protos::LearningRate>(GetArenaForAllocation());
    _impl_.learning_rate_ = p;
  }
  return _impl_.learning_rate_;
}
inline ::second::protos::LearningRate* MomentumOptimizer::mutable_learning_rate() {
  ::second::protos::LearningRate* _msg = _internal_mutable_learning_rate();
  // @@protoc_insertion_point(field_mutable:second.protos.MomentumOptimizer.learning_rate)
  return _msg;
}
inline void MomentumOptimizer::set_allocated_learning_rate(::second::protos::LearningRate* learning_rate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.learning_rate_;
  }
  if (learning_rate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(learning_rate);
    if (message_arena != submessage_arena) {
      learning_rate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, learning_rate, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.learning_rate_ = learning_rate;
  // @@protoc_insertion_point(field_set_allocated:second.protos.MomentumOptimizer.learning_rate)
}

// float momentum_optimizer_value = 2;
inline void MomentumOptimizer::clear_momentum_optimizer_value() {
  _impl_.momentum_optimizer_value_ = 0;
}
inline float MomentumOptimizer::_internal_momentum_optimizer_value() const {
  return _impl_.momentum_optimizer_value_;
}
inline float MomentumOptimizer::momentum_optimizer_value() const {
  // @@protoc_insertion_point(field_get:second.protos.MomentumOptimizer.momentum_optimizer_value)
  return _internal_momentum_optimizer_value();
}
inline void MomentumOptimizer::_internal_set_momentum_optimizer_value(float value) {
  
  _impl_.momentum_optimizer_value_ = value;
}
inline void MomentumOptimizer::set_momentum_optimizer_value(float value) {
  _internal_set_momentum_optimizer_value(value);
  // @@protoc_insertion_point(field_set:second.protos.MomentumOptimizer.momentum_optimizer_value)
}

// float weight_decay = 3;
inline void MomentumOptimizer::clear_weight_decay() {
  _impl_.weight_decay_ = 0;
}
inline float MomentumOptimizer::_internal_weight_decay() const {
  return _impl_.weight_decay_;
}
inline float MomentumOptimizer::weight_decay() const {
  // @@protoc_insertion_point(field_get:second.protos.MomentumOptimizer.weight_decay)
  return _internal_weight_decay();
}
inline void MomentumOptimizer::_internal_set_weight_decay(float value) {
  
  _impl_.weight_decay_ = value;
}
inline void MomentumOptimizer::set_weight_decay(float value) {
  _internal_set_weight_decay(value);
  // @@protoc_insertion_point(field_set:second.protos.MomentumOptimizer.weight_decay)
}

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

// AdamOptimizer

// .second.protos.LearningRate learning_rate = 1;
inline bool AdamOptimizer::_internal_has_learning_rate() const {
  return this != internal_default_instance() && _impl_.learning_rate_ != nullptr;
}
inline bool AdamOptimizer::has_learning_rate() const {
  return _internal_has_learning_rate();
}
inline void AdamOptimizer::clear_learning_rate() {
  if (GetArenaForAllocation() == nullptr && _impl_.learning_rate_ != nullptr) {
    delete _impl_.learning_rate_;
  }
  _impl_.learning_rate_ = nullptr;
}
inline const ::second::protos::LearningRate& AdamOptimizer::_internal_learning_rate() const {
  const ::second::protos::LearningRate* p = _impl_.learning_rate_;
  return p != nullptr ? *p : reinterpret_cast<const ::second::protos::LearningRate&>(
      ::second::protos::_LearningRate_default_instance_);
}
inline const ::second::protos::LearningRate& AdamOptimizer::learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.AdamOptimizer.learning_rate)
  return _internal_learning_rate();
}
inline void AdamOptimizer::unsafe_arena_set_allocated_learning_rate(
    ::second::protos::LearningRate* learning_rate) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.learning_rate_);
  }
  _impl_.learning_rate_ = learning_rate;
  if (learning_rate) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.AdamOptimizer.learning_rate)
}
inline ::second::protos::LearningRate* AdamOptimizer::release_learning_rate() {
  
  ::second::protos::LearningRate* temp = _impl_.learning_rate_;
  _impl_.learning_rate_ = 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::LearningRate* AdamOptimizer::unsafe_arena_release_learning_rate() {
  // @@protoc_insertion_point(field_release:second.protos.AdamOptimizer.learning_rate)
  
  ::second::protos::LearningRate* temp = _impl_.learning_rate_;
  _impl_.learning_rate_ = nullptr;
  return temp;
}
inline ::second::protos::LearningRate* AdamOptimizer::_internal_mutable_learning_rate() {
  
  if (_impl_.learning_rate_ == nullptr) {
    auto* p = CreateMaybeMessage<::second::protos::LearningRate>(GetArenaForAllocation());
    _impl_.learning_rate_ = p;
  }
  return _impl_.learning_rate_;
}
inline ::second::protos::LearningRate* AdamOptimizer::mutable_learning_rate() {
  ::second::protos::LearningRate* _msg = _internal_mutable_learning_rate();
  // @@protoc_insertion_point(field_mutable:second.protos.AdamOptimizer.learning_rate)
  return _msg;
}
inline void AdamOptimizer::set_allocated_learning_rate(::second::protos::LearningRate* learning_rate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.learning_rate_;
  }
  if (learning_rate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(learning_rate);
    if (message_arena != submessage_arena) {
      learning_rate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, learning_rate, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.learning_rate_ = learning_rate;
  // @@protoc_insertion_point(field_set_allocated:second.protos.AdamOptimizer.learning_rate)
}

// float weight_decay = 2;
inline void AdamOptimizer::clear_weight_decay() {
  _impl_.weight_decay_ = 0;
}
inline float AdamOptimizer::_internal_weight_decay() const {
  return _impl_.weight_decay_;
}
inline float AdamOptimizer::weight_decay() const {
  // @@protoc_insertion_point(field_get:second.protos.AdamOptimizer.weight_decay)
  return _internal_weight_decay();
}
inline void AdamOptimizer::_internal_set_weight_decay(float value) {
  
  _impl_.weight_decay_ = value;
}
inline void AdamOptimizer::set_weight_decay(float value) {
  _internal_set_weight_decay(value);
  // @@protoc_insertion_point(field_set:second.protos.AdamOptimizer.weight_decay)
}

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

// LearningRate

// .second.protos.ConstantLearningRate constant_learning_rate = 1;
inline bool LearningRate::_internal_has_constant_learning_rate() const {
  return learning_rate_case() == kConstantLearningRate;
}
inline bool LearningRate::has_constant_learning_rate() const {
  return _internal_has_constant_learning_rate();
}
inline void LearningRate::set_has_constant_learning_rate() {
  _impl_._oneof_case_[0] = kConstantLearningRate;
}
inline void LearningRate::clear_constant_learning_rate() {
  if (_internal_has_constant_learning_rate()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.learning_rate_.constant_learning_rate_;
    }
    clear_has_learning_rate();
  }
}
inline ::second::protos::ConstantLearningRate* LearningRate::release_constant_learning_rate() {
  // @@protoc_insertion_point(field_release:second.protos.LearningRate.constant_learning_rate)
  if (_internal_has_constant_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::ConstantLearningRate* temp = _impl_.learning_rate_.constant_learning_rate_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.learning_rate_.constant_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::ConstantLearningRate& LearningRate::_internal_constant_learning_rate() const {
  return _internal_has_constant_learning_rate()
      ? *_impl_.learning_rate_.constant_learning_rate_
      : reinterpret_cast< ::second::protos::ConstantLearningRate&>(::second::protos::_ConstantLearningRate_default_instance_);
}
inline const ::second::protos::ConstantLearningRate& LearningRate::constant_learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.LearningRate.constant_learning_rate)
  return _internal_constant_learning_rate();
}
inline ::second::protos::ConstantLearningRate* LearningRate::unsafe_arena_release_constant_learning_rate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.LearningRate.constant_learning_rate)
  if (_internal_has_constant_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::ConstantLearningRate* temp = _impl_.learning_rate_.constant_learning_rate_;
    _impl_.learning_rate_.constant_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LearningRate::unsafe_arena_set_allocated_constant_learning_rate(::second::protos::ConstantLearningRate* constant_learning_rate) {
  clear_learning_rate();
  if (constant_learning_rate) {
    set_has_constant_learning_rate();
    _impl_.learning_rate_.constant_learning_rate_ = constant_learning_rate;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.LearningRate.constant_learning_rate)
}
inline ::second::protos::ConstantLearningRate* LearningRate::_internal_mutable_constant_learning_rate() {
  if (!_internal_has_constant_learning_rate()) {
    clear_learning_rate();
    set_has_constant_learning_rate();
    _impl_.learning_rate_.constant_learning_rate_ = CreateMaybeMessage< ::second::protos::ConstantLearningRate >(GetArenaForAllocation());
  }
  return _impl_.learning_rate_.constant_learning_rate_;
}
inline ::second::protos::ConstantLearningRate* LearningRate::mutable_constant_learning_rate() {
  ::second::protos::ConstantLearningRate* _msg = _internal_mutable_constant_learning_rate();
  // @@protoc_insertion_point(field_mutable:second.protos.LearningRate.constant_learning_rate)
  return _msg;
}

// .second.protos.ExponentialDecayLearningRate exponential_decay_learning_rate = 2;
inline bool LearningRate::_internal_has_exponential_decay_learning_rate() const {
  return learning_rate_case() == kExponentialDecayLearningRate;
}
inline bool LearningRate::has_exponential_decay_learning_rate() const {
  return _internal_has_exponential_decay_learning_rate();
}
inline void LearningRate::set_has_exponential_decay_learning_rate() {
  _impl_._oneof_case_[0] = kExponentialDecayLearningRate;
}
inline void LearningRate::clear_exponential_decay_learning_rate() {
  if (_internal_has_exponential_decay_learning_rate()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.learning_rate_.exponential_decay_learning_rate_;
    }
    clear_has_learning_rate();
  }
}
inline ::second::protos::ExponentialDecayLearningRate* LearningRate::release_exponential_decay_learning_rate() {
  // @@protoc_insertion_point(field_release:second.protos.LearningRate.exponential_decay_learning_rate)
  if (_internal_has_exponential_decay_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::ExponentialDecayLearningRate* temp = _impl_.learning_rate_.exponential_decay_learning_rate_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.learning_rate_.exponential_decay_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::ExponentialDecayLearningRate& LearningRate::_internal_exponential_decay_learning_rate() const {
  return _internal_has_exponential_decay_learning_rate()
      ? *_impl_.learning_rate_.exponential_decay_learning_rate_
      : reinterpret_cast< ::second::protos::ExponentialDecayLearningRate&>(::second::protos::_ExponentialDecayLearningRate_default_instance_);
}
inline const ::second::protos::ExponentialDecayLearningRate& LearningRate::exponential_decay_learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.LearningRate.exponential_decay_learning_rate)
  return _internal_exponential_decay_learning_rate();
}
inline ::second::protos::ExponentialDecayLearningRate* LearningRate::unsafe_arena_release_exponential_decay_learning_rate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.LearningRate.exponential_decay_learning_rate)
  if (_internal_has_exponential_decay_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::ExponentialDecayLearningRate* temp = _impl_.learning_rate_.exponential_decay_learning_rate_;
    _impl_.learning_rate_.exponential_decay_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LearningRate::unsafe_arena_set_allocated_exponential_decay_learning_rate(::second::protos::ExponentialDecayLearningRate* exponential_decay_learning_rate) {
  clear_learning_rate();
  if (exponential_decay_learning_rate) {
    set_has_exponential_decay_learning_rate();
    _impl_.learning_rate_.exponential_decay_learning_rate_ = exponential_decay_learning_rate;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.LearningRate.exponential_decay_learning_rate)
}
inline ::second::protos::ExponentialDecayLearningRate* LearningRate::_internal_mutable_exponential_decay_learning_rate() {
  if (!_internal_has_exponential_decay_learning_rate()) {
    clear_learning_rate();
    set_has_exponential_decay_learning_rate();
    _impl_.learning_rate_.exponential_decay_learning_rate_ = CreateMaybeMessage< ::second::protos::ExponentialDecayLearningRate >(GetArenaForAllocation());
  }
  return _impl_.learning_rate_.exponential_decay_learning_rate_;
}
inline ::second::protos::ExponentialDecayLearningRate* LearningRate::mutable_exponential_decay_learning_rate() {
  ::second::protos::ExponentialDecayLearningRate* _msg = _internal_mutable_exponential_decay_learning_rate();
  // @@protoc_insertion_point(field_mutable:second.protos.LearningRate.exponential_decay_learning_rate)
  return _msg;
}

// .second.protos.ManualStepLearningRate manual_step_learning_rate = 3;
inline bool LearningRate::_internal_has_manual_step_learning_rate() const {
  return learning_rate_case() == kManualStepLearningRate;
}
inline bool LearningRate::has_manual_step_learning_rate() const {
  return _internal_has_manual_step_learning_rate();
}
inline void LearningRate::set_has_manual_step_learning_rate() {
  _impl_._oneof_case_[0] = kManualStepLearningRate;
}
inline void LearningRate::clear_manual_step_learning_rate() {
  if (_internal_has_manual_step_learning_rate()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.learning_rate_.manual_step_learning_rate_;
    }
    clear_has_learning_rate();
  }
}
inline ::second::protos::ManualStepLearningRate* LearningRate::release_manual_step_learning_rate() {
  // @@protoc_insertion_point(field_release:second.protos.LearningRate.manual_step_learning_rate)
  if (_internal_has_manual_step_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::ManualStepLearningRate* temp = _impl_.learning_rate_.manual_step_learning_rate_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.learning_rate_.manual_step_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::ManualStepLearningRate& LearningRate::_internal_manual_step_learning_rate() const {
  return _internal_has_manual_step_learning_rate()
      ? *_impl_.learning_rate_.manual_step_learning_rate_
      : reinterpret_cast< ::second::protos::ManualStepLearningRate&>(::second::protos::_ManualStepLearningRate_default_instance_);
}
inline const ::second::protos::ManualStepLearningRate& LearningRate::manual_step_learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.LearningRate.manual_step_learning_rate)
  return _internal_manual_step_learning_rate();
}
inline ::second::protos::ManualStepLearningRate* LearningRate::unsafe_arena_release_manual_step_learning_rate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.LearningRate.manual_step_learning_rate)
  if (_internal_has_manual_step_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::ManualStepLearningRate* temp = _impl_.learning_rate_.manual_step_learning_rate_;
    _impl_.learning_rate_.manual_step_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LearningRate::unsafe_arena_set_allocated_manual_step_learning_rate(::second::protos::ManualStepLearningRate* manual_step_learning_rate) {
  clear_learning_rate();
  if (manual_step_learning_rate) {
    set_has_manual_step_learning_rate();
    _impl_.learning_rate_.manual_step_learning_rate_ = manual_step_learning_rate;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.LearningRate.manual_step_learning_rate)
}
inline ::second::protos::ManualStepLearningRate* LearningRate::_internal_mutable_manual_step_learning_rate() {
  if (!_internal_has_manual_step_learning_rate()) {
    clear_learning_rate();
    set_has_manual_step_learning_rate();
    _impl_.learning_rate_.manual_step_learning_rate_ = CreateMaybeMessage< ::second::protos::ManualStepLearningRate >(GetArenaForAllocation());
  }
  return _impl_.learning_rate_.manual_step_learning_rate_;
}
inline ::second::protos::ManualStepLearningRate* LearningRate::mutable_manual_step_learning_rate() {
  ::second::protos::ManualStepLearningRate* _msg = _internal_mutable_manual_step_learning_rate();
  // @@protoc_insertion_point(field_mutable:second.protos.LearningRate.manual_step_learning_rate)
  return _msg;
}

// .second.protos.CosineDecayLearningRate cosine_decay_learning_rate = 4;
inline bool LearningRate::_internal_has_cosine_decay_learning_rate() const {
  return learning_rate_case() == kCosineDecayLearningRate;
}
inline bool LearningRate::has_cosine_decay_learning_rate() const {
  return _internal_has_cosine_decay_learning_rate();
}
inline void LearningRate::set_has_cosine_decay_learning_rate() {
  _impl_._oneof_case_[0] = kCosineDecayLearningRate;
}
inline void LearningRate::clear_cosine_decay_learning_rate() {
  if (_internal_has_cosine_decay_learning_rate()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.learning_rate_.cosine_decay_learning_rate_;
    }
    clear_has_learning_rate();
  }
}
inline ::second::protos::CosineDecayLearningRate* LearningRate::release_cosine_decay_learning_rate() {
  // @@protoc_insertion_point(field_release:second.protos.LearningRate.cosine_decay_learning_rate)
  if (_internal_has_cosine_decay_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::CosineDecayLearningRate* temp = _impl_.learning_rate_.cosine_decay_learning_rate_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.learning_rate_.cosine_decay_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::CosineDecayLearningRate& LearningRate::_internal_cosine_decay_learning_rate() const {
  return _internal_has_cosine_decay_learning_rate()
      ? *_impl_.learning_rate_.cosine_decay_learning_rate_
      : reinterpret_cast< ::second::protos::CosineDecayLearningRate&>(::second::protos::_CosineDecayLearningRate_default_instance_);
}
inline const ::second::protos::CosineDecayLearningRate& LearningRate::cosine_decay_learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.LearningRate.cosine_decay_learning_rate)
  return _internal_cosine_decay_learning_rate();
}
inline ::second::protos::CosineDecayLearningRate* LearningRate::unsafe_arena_release_cosine_decay_learning_rate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.LearningRate.cosine_decay_learning_rate)
  if (_internal_has_cosine_decay_learning_rate()) {
    clear_has_learning_rate();
    ::second::protos::CosineDecayLearningRate* temp = _impl_.learning_rate_.cosine_decay_learning_rate_;
    _impl_.learning_rate_.cosine_decay_learning_rate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LearningRate::unsafe_arena_set_allocated_cosine_decay_learning_rate(::second::protos::CosineDecayLearningRate* cosine_decay_learning_rate) {
  clear_learning_rate();
  if (cosine_decay_learning_rate) {
    set_has_cosine_decay_learning_rate();
    _impl_.learning_rate_.cosine_decay_learning_rate_ = cosine_decay_learning_rate;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.LearningRate.cosine_decay_learning_rate)
}
inline ::second::protos::CosineDecayLearningRate* LearningRate::_internal_mutable_cosine_decay_learning_rate() {
  if (!_internal_has_cosine_decay_learning_rate()) {
    clear_learning_rate();
    set_has_cosine_decay_learning_rate();
    _impl_.learning_rate_.cosine_decay_learning_rate_ = CreateMaybeMessage< ::second::protos::CosineDecayLearningRate >(GetArenaForAllocation());
  }
  return _impl_.learning_rate_.cosine_decay_learning_rate_;
}
inline ::second::protos::CosineDecayLearningRate* LearningRate::mutable_cosine_decay_learning_rate() {
  ::second::protos::CosineDecayLearningRate* _msg = _internal_mutable_cosine_decay_learning_rate();
  // @@protoc_insertion_point(field_mutable:second.protos.LearningRate.cosine_decay_learning_rate)
  return _msg;
}

inline bool LearningRate::has_learning_rate() const {
  return learning_rate_case() != LEARNING_RATE_NOT_SET;
}
inline void LearningRate::clear_has_learning_rate() {
  _impl_._oneof_case_[0] = LEARNING_RATE_NOT_SET;
}
inline LearningRate::LearningRateCase LearningRate::learning_rate_case() const {
  return LearningRate::LearningRateCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// ConstantLearningRate

// float learning_rate = 1;
inline void ConstantLearningRate::clear_learning_rate() {
  _impl_.learning_rate_ = 0;
}
inline float ConstantLearningRate::_internal_learning_rate() const {
  return _impl_.learning_rate_;
}
inline float ConstantLearningRate::learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.ConstantLearningRate.learning_rate)
  return _internal_learning_rate();
}
inline void ConstantLearningRate::_internal_set_learning_rate(float value) {
  
  _impl_.learning_rate_ = value;
}
inline void ConstantLearningRate::set_learning_rate(float value) {
  _internal_set_learning_rate(value);
  // @@protoc_insertion_point(field_set:second.protos.ConstantLearningRate.learning_rate)
}

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

// ExponentialDecayLearningRate

// float initial_learning_rate = 1;
inline void ExponentialDecayLearningRate::clear_initial_learning_rate() {
  _impl_.initial_learning_rate_ = 0;
}
inline float ExponentialDecayLearningRate::_internal_initial_learning_rate() const {
  return _impl_.initial_learning_rate_;
}
inline float ExponentialDecayLearningRate::initial_learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.ExponentialDecayLearningRate.initial_learning_rate)
  return _internal_initial_learning_rate();
}
inline void ExponentialDecayLearningRate::_internal_set_initial_learning_rate(float value) {
  
  _impl_.initial_learning_rate_ = value;
}
inline void ExponentialDecayLearningRate::set_initial_learning_rate(float value) {
  _internal_set_initial_learning_rate(value);
  // @@protoc_insertion_point(field_set:second.protos.ExponentialDecayLearningRate.initial_learning_rate)
}

// uint32 decay_steps = 2;
inline void ExponentialDecayLearningRate::clear_decay_steps() {
  _impl_.decay_steps_ = 0u;
}
inline uint32_t ExponentialDecayLearningRate::_internal_decay_steps() const {
  return _impl_.decay_steps_;
}
inline uint32_t ExponentialDecayLearningRate::decay_steps() const {
  // @@protoc_insertion_point(field_get:second.protos.ExponentialDecayLearningRate.decay_steps)
  return _internal_decay_steps();
}
inline void ExponentialDecayLearningRate::_internal_set_decay_steps(uint32_t value) {
  
  _impl_.decay_steps_ = value;
}
inline void ExponentialDecayLearningRate::set_decay_steps(uint32_t value) {
  _internal_set_decay_steps(value);
  // @@protoc_insertion_point(field_set:second.protos.ExponentialDecayLearningRate.decay_steps)
}

// float decay_factor = 3;
inline void ExponentialDecayLearningRate::clear_decay_factor() {
  _impl_.decay_factor_ = 0;
}
inline float ExponentialDecayLearningRate::_internal_decay_factor() const {
  return _impl_.decay_factor_;
}
inline float ExponentialDecayLearningRate::decay_factor() const {
  // @@protoc_insertion_point(field_get:second.protos.ExponentialDecayLearningRate.decay_factor)
  return _internal_decay_factor();
}
inline void ExponentialDecayLearningRate::_internal_set_decay_factor(float value) {
  
  _impl_.decay_factor_ = value;
}
inline void ExponentialDecayLearningRate::set_decay_factor(float value) {
  _internal_set_decay_factor(value);
  // @@protoc_insertion_point(field_set:second.protos.ExponentialDecayLearningRate.decay_factor)
}

// bool staircase = 4;
inline void ExponentialDecayLearningRate::clear_staircase() {
  _impl_.staircase_ = false;
}
inline bool ExponentialDecayLearningRate::_internal_staircase() const {
  return _impl_.staircase_;
}
inline bool ExponentialDecayLearningRate::staircase() const {
  // @@protoc_insertion_point(field_get:second.protos.ExponentialDecayLearningRate.staircase)
  return _internal_staircase();
}
inline void ExponentialDecayLearningRate::_internal_set_staircase(bool value) {
  
  _impl_.staircase_ = value;
}
inline void ExponentialDecayLearningRate::set_staircase(bool value) {
  _internal_set_staircase(value);
  // @@protoc_insertion_point(field_set:second.protos.ExponentialDecayLearningRate.staircase)
}

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

// ManualStepLearningRate_LearningRateSchedule

// uint32 step = 1;
inline void ManualStepLearningRate_LearningRateSchedule::clear_step() {
  _impl_.step_ = 0u;
}
inline uint32_t ManualStepLearningRate_LearningRateSchedule::_internal_step() const {
  return _impl_.step_;
}
inline uint32_t ManualStepLearningRate_LearningRateSchedule::step() const {
  // @@protoc_insertion_point(field_get:second.protos.ManualStepLearningRate.LearningRateSchedule.step)
  return _internal_step();
}
inline void ManualStepLearningRate_LearningRateSchedule::_internal_set_step(uint32_t value) {
  
  _impl_.step_ = value;
}
inline void ManualStepLearningRate_LearningRateSchedule::set_step(uint32_t value) {
  _internal_set_step(value);
  // @@protoc_insertion_point(field_set:second.protos.ManualStepLearningRate.LearningRateSchedule.step)
}

// float learning_rate = 2;
inline void ManualStepLearningRate_LearningRateSchedule::clear_learning_rate() {
  _impl_.learning_rate_ = 0;
}
inline float ManualStepLearningRate_LearningRateSchedule::_internal_learning_rate() const {
  return _impl_.learning_rate_;
}
inline float ManualStepLearningRate_LearningRateSchedule::learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.ManualStepLearningRate.LearningRateSchedule.learning_rate)
  return _internal_learning_rate();
}
inline void ManualStepLearningRate_LearningRateSchedule::_internal_set_learning_rate(float value) {
  
  _impl_.learning_rate_ = value;
}
inline void ManualStepLearningRate_LearningRateSchedule::set_learning_rate(float value) {
  _internal_set_learning_rate(value);
  // @@protoc_insertion_point(field_set:second.protos.ManualStepLearningRate.LearningRateSchedule.learning_rate)
}

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

// ManualStepLearningRate

// float initial_learning_rate = 1;
inline void ManualStepLearningRate::clear_initial_learning_rate() {
  _impl_.initial_learning_rate_ = 0;
}
inline float ManualStepLearningRate::_internal_initial_learning_rate() const {
  return _impl_.initial_learning_rate_;
}
inline float ManualStepLearningRate::initial_learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.ManualStepLearningRate.initial_learning_rate)
  return _internal_initial_learning_rate();
}
inline void ManualStepLearningRate::_internal_set_initial_learning_rate(float value) {
  
  _impl_.initial_learning_rate_ = value;
}
inline void ManualStepLearningRate::set_initial_learning_rate(float value) {
  _internal_set_initial_learning_rate(value);
  // @@protoc_insertion_point(field_set:second.protos.ManualStepLearningRate.initial_learning_rate)
}

// repeated .second.protos.ManualStepLearningRate.LearningRateSchedule schedule = 2;
inline int ManualStepLearningRate::_internal_schedule_size() const {
  return _impl_.schedule_.size();
}
inline int ManualStepLearningRate::schedule_size() const {
  return _internal_schedule_size();
}
inline void ManualStepLearningRate::clear_schedule() {
  _impl_.schedule_.Clear();
}
inline ::second::protos::ManualStepLearningRate_LearningRateSchedule* ManualStepLearningRate::mutable_schedule(int index) {
  // @@protoc_insertion_point(field_mutable:second.protos.ManualStepLearningRate.schedule)
  return _impl_.schedule_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::second::protos::ManualStepLearningRate_LearningRateSchedule >*
ManualStepLearningRate::mutable_schedule() {
  // @@protoc_insertion_point(field_mutable_list:second.protos.ManualStepLearningRate.schedule)
  return &_impl_.schedule_;
}
inline const ::second::protos::ManualStepLearningRate_LearningRateSchedule& ManualStepLearningRate::_internal_schedule(int index) const {
  return _impl_.schedule_.Get(index);
}
inline const ::second::protos::ManualStepLearningRate_LearningRateSchedule& ManualStepLearningRate::schedule(int index) const {
  // @@protoc_insertion_point(field_get:second.protos.ManualStepLearningRate.schedule)
  return _internal_schedule(index);
}
inline ::second::protos::ManualStepLearningRate_LearningRateSchedule* ManualStepLearningRate::_internal_add_schedule() {
  return _impl_.schedule_.Add();
}
inline ::second::protos::ManualStepLearningRate_LearningRateSchedule* ManualStepLearningRate::add_schedule() {
  ::second::protos::ManualStepLearningRate_LearningRateSchedule* _add = _internal_add_schedule();
  // @@protoc_insertion_point(field_add:second.protos.ManualStepLearningRate.schedule)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::second::protos::ManualStepLearningRate_LearningRateSchedule >&
ManualStepLearningRate::schedule() const {
  // @@protoc_insertion_point(field_list:second.protos.ManualStepLearningRate.schedule)
  return _impl_.schedule_;
}

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

// CosineDecayLearningRate

// float learning_rate_base = 1;
inline void CosineDecayLearningRate::clear_learning_rate_base() {
  _impl_.learning_rate_base_ = 0;
}
inline float CosineDecayLearningRate::_internal_learning_rate_base() const {
  return _impl_.learning_rate_base_;
}
inline float CosineDecayLearningRate::learning_rate_base() const {
  // @@protoc_insertion_point(field_get:second.protos.CosineDecayLearningRate.learning_rate_base)
  return _internal_learning_rate_base();
}
inline void CosineDecayLearningRate::_internal_set_learning_rate_base(float value) {
  
  _impl_.learning_rate_base_ = value;
}
inline void CosineDecayLearningRate::set_learning_rate_base(float value) {
  _internal_set_learning_rate_base(value);
  // @@protoc_insertion_point(field_set:second.protos.CosineDecayLearningRate.learning_rate_base)
}

// uint32 total_steps = 2;
inline void CosineDecayLearningRate::clear_total_steps() {
  _impl_.total_steps_ = 0u;
}
inline uint32_t CosineDecayLearningRate::_internal_total_steps() const {
  return _impl_.total_steps_;
}
inline uint32_t CosineDecayLearningRate::total_steps() const {
  // @@protoc_insertion_point(field_get:second.protos.CosineDecayLearningRate.total_steps)
  return _internal_total_steps();
}
inline void CosineDecayLearningRate::_internal_set_total_steps(uint32_t value) {
  
  _impl_.total_steps_ = value;
}
inline void CosineDecayLearningRate::set_total_steps(uint32_t value) {
  _internal_set_total_steps(value);
  // @@protoc_insertion_point(field_set:second.protos.CosineDecayLearningRate.total_steps)
}

// float warmup_learning_rate = 3;
inline void CosineDecayLearningRate::clear_warmup_learning_rate() {
  _impl_.warmup_learning_rate_ = 0;
}
inline float CosineDecayLearningRate::_internal_warmup_learning_rate() const {
  return _impl_.warmup_learning_rate_;
}
inline float CosineDecayLearningRate::warmup_learning_rate() const {
  // @@protoc_insertion_point(field_get:second.protos.CosineDecayLearningRate.warmup_learning_rate)
  return _internal_warmup_learning_rate();
}
inline void CosineDecayLearningRate::_internal_set_warmup_learning_rate(float value) {
  
  _impl_.warmup_learning_rate_ = value;
}
inline void CosineDecayLearningRate::set_warmup_learning_rate(float value) {
  _internal_set_warmup_learning_rate(value);
  // @@protoc_insertion_point(field_set:second.protos.CosineDecayLearningRate.warmup_learning_rate)
}

// uint32 warmup_steps = 4;
inline void CosineDecayLearningRate::clear_warmup_steps() {
  _impl_.warmup_steps_ = 0u;
}
inline uint32_t CosineDecayLearningRate::_internal_warmup_steps() const {
  return _impl_.warmup_steps_;
}
inline uint32_t CosineDecayLearningRate::warmup_steps() const {
  // @@protoc_insertion_point(field_get:second.protos.CosineDecayLearningRate.warmup_steps)
  return _internal_warmup_steps();
}
inline void CosineDecayLearningRate::_internal_set_warmup_steps(uint32_t value) {
  
  _impl_.warmup_steps_ = value;
}
inline void CosineDecayLearningRate::set_warmup_steps(uint32_t value) {
  _internal_set_warmup_steps(value);
  // @@protoc_insertion_point(field_set:second.protos.CosineDecayLearningRate.warmup_steps)
}

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace second

// @@protoc_insertion_point(global_scope)

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