sgdr.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_SGDR_SGDR_HPP
#define MLPACK_CORE_OPTIMIZERS_SGDR_SGDR_HPP

#include <mlpack/prereqs.hpp>

#include <mlpack/core/optimizers/sgd/sgd.hpp>
#include <mlpack/core/optimizers/sgd/update_policies/momentum_update.hpp>
#include "cyclical_decay.hpp"

namespace mlpack {
namespace optimization {

template<typename UpdatePolicyType = MomentumUpdate>
class SGDR
{
 public:
  using OptimizerType = SGD<UpdatePolicyType, CyclicalDecay>;

  SGDR(const size_t epochRestart = 50,
       const double multFactor = 2.0,
       const size_t batchSize = 1000,
       const double stepSize = 0.01,
       const size_t maxIterations = 100000,
       const double tolerance = 1e-5,
       const bool shuffle = true,
       const UpdatePolicyType& updatePolicy = UpdatePolicyType());

  template<typename DecomposableFunctionType>
  double Optimize(DecomposableFunctionType& function, arma::mat& iterate);

  size_t BatchSize() const { return optimizer.BatchSize(); }
  size_t& BatchSize() { return optimizer.BatchSize(); }

  double StepSize() const { return optimizer.StepSize(); }
  double& StepSize() { return optimizer.StepSize(); }

  size_t MaxIterations() const { return optimizer.MaxIterations(); }
  size_t& MaxIterations() { return optimizer.MaxIterations(); }

  double Tolerance() const { return optimizer.Tolerance(); }
  double& Tolerance() { return optimizer.Tolerance(); }

  bool Shuffle() const { return optimizer.Shuffle(); }
  bool& Shuffle() { return optimizer.Shuffle(); }

  const UpdatePolicyType& UpdatePolicy() const
  {
    return optimizer.UpdatePolicy();
  }
  UpdatePolicyType& UpdatePolicy()
  {
    return optimizer.UpdatePolicy();
  }

 private:
  size_t batchSize;

  OptimizerType optimizer;
};

} // namespace optimization
} // namespace mlpack

// Include implementation.
#include "sgdr_impl.hpp"

#endif