lbfgs.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_LBFGS_LBFGS_HPP
#define MLPACK_CORE_OPTIMIZERS_LBFGS_LBFGS_HPP

#include <mlpack/prereqs.hpp>

namespace mlpack {
namespace optimization {

template<typename FunctionType>
class L_BFGS
{
 public:
  L_BFGS(FunctionType& function,
         const size_t numBasis = 10, /* same default as scipy */
         const size_t maxIterations = 10000, /* many but not infinite */
         const double armijoConstant = 1e-4,
         const double wolfe = 0.9,
         const double minGradientNorm = 1e-6,
         const double factr = 1e-15,
         const size_t maxLineSearchTrials = 50,
         const double minStep = 1e-20,
         const double maxStep = 1e20);

  const std::pair<arma::mat, double>& MinPointIterate() const;

  double Optimize(arma::mat& iterate);

  double Optimize(arma::mat& iterate, const size_t maxIterations);

  const FunctionType& Function() const { return function; }
  FunctionType& Function() { return function; }

  size_t NumBasis() const { return numBasis; }
  size_t& NumBasis() { return numBasis; }

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

  double ArmijoConstant() const { return armijoConstant; }
  double& ArmijoConstant() { return armijoConstant; }

  double Wolfe() const { return wolfe; }
  double& Wolfe() { return wolfe; }

  double MinGradientNorm() const { return minGradientNorm; }
  double& MinGradientNorm() { return minGradientNorm; }

  double Factr() const { return factr; }
  double& Factr() { return factr; }

  size_t MaxLineSearchTrials() const { return maxLineSearchTrials; }
  size_t& MaxLineSearchTrials() { return maxLineSearchTrials; }

  double MinStep() const { return minStep; }
  double& MinStep() { return minStep; }

  double MaxStep() const { return maxStep; }
  double& MaxStep() { return maxStep; }

 private:
  FunctionType& function;

  arma::mat newIterateTmp;
  arma::cube s;
  arma::cube y;

  size_t numBasis;
  size_t maxIterations;
  double armijoConstant;
  double wolfe;
  double minGradientNorm;
  double factr;
  size_t maxLineSearchTrials;
  double minStep;
  double maxStep;

  std::pair<arma::mat, double> minPointIterate;

  double Evaluate(const arma::mat& iterate);

  double ChooseScalingFactor(const size_t iterationNum,
                             const arma::mat& gradient);

  bool GradientNormTooSmall(const arma::mat& gradient);

  bool LineSearch(double& functionValue,
                  arma::mat& iterate,
                  arma::mat& gradient,
                  const arma::mat& searchDirection);

  void SearchDirection(const arma::mat& gradient,
                       const size_t iterationNum,
                       const double scalingFactor,
                       arma::mat& searchDirection);

  void UpdateBasisSet(const size_t iterationNum,
                      const arma::mat& iterate,
                      const arma::mat& oldIterate,
                      const arma::mat& gradient,
                      const arma::mat& oldGradient);
};

} // namespace optimization
} // namespace mlpack

#include "lbfgs_impl.hpp"

#endif // MLPACK_CORE_OPTIMIZERS_LBFGS_LBFGS_HPP