bigbatch_sgd.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_BIGBATCH_SGD_BIGBATCH_SGD_HPP
#define MLPACK_CORE_OPTIMIZERS_BIGBATCH_SGD_BIGBATCH_SGD_HPP

#include <mlpack/prereqs.hpp>

#include "adaptive_stepsize.hpp"
#include "backtracking_line_search.hpp"

namespace mlpack {
namespace optimization {

template<typename UpdatePolicyType = AdaptiveStepsize>
class BigBatchSGD
{
 public:
  BigBatchSGD(const size_t batchSize = 1000,
              const double stepSize = 0.01,
              const double batchDelta = 0.1,
              const size_t maxIterations = 100000,
              const double tolerance = 1e-5,
              const bool shuffle = true);
  template<typename DecomposableFunctionType>
  double Optimize(DecomposableFunctionType& function,
                  arma::mat& iterate);

  size_t BatchSize() const { return batchSize; }
  size_t& BatchSize() { return batchSize; }

  double StepSize() const { return stepSize; }
  double& StepSize() { return stepSize; }

  double BatchDelta() const { return batchDelta; }
  double& BatchDelta() { return batchDelta; }

  size_t MaxIterations() const { return maxIterations; }
  size_t& MaxIterations() { return maxIterations; }

  double Tolerance() const { return tolerance; }
  double& Tolerance() { return tolerance; }

  bool Shuffle() const { return shuffle; }
  bool& Shuffle() { return shuffle; }

  UpdatePolicyType UpdatePolicy() const { return updatePolicy; }
  UpdatePolicyType& UpdatePolicy() { return updatePolicy; }

 private:
  size_t batchSize;

  double stepSize;

  double batchDelta;

  size_t maxIterations;

  double tolerance;

  bool shuffle;

  UpdatePolicyType updatePolicy;
};

using BBS_Armijo = BigBatchSGD<BacktrackingLineSearch>;
using BBS_BB = BigBatchSGD<AdaptiveStepsize>;

} // namespace optimization
} // namespace mlpack

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

#endif