snapshot_sgdr.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_SGDR_SNAPSHOT_SGDR_HPP
#define MLPACK_CORE_OPTIMIZERS_SGDR_SNAPSHOT_SGDR_HPP

#include <mlpack/prereqs.hpp>

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

namespace mlpack {
namespace optimization {

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

  SnapshotSGDR(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 size_t snapshots = 5,
               const bool accumulate = 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(); }

  std::vector<arma::mat> Snapshots() const
  {
    return optimizer.DecayPolicy().Snapshots();
  }
  std::vector<arma::mat>& Snapshots()
  {
    return optimizer.DecayPolicy().Snapshots();
  }

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

 private:
  size_t batchSize;

  bool accumulate;

  OptimizerType optimizer;
};

} // namespace optimization
} // namespace mlpack

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

#endif