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>
#include <mlpack/core/optimizers/function.hpp>

namespace mlpack {
namespace optimization {

class L_BFGS
{
 public:
  L_BFGS(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;

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

  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:
  size_t numBasis;
  size_t maxIterations;
  double armijoConstant;
  double wolfe;
  double minGradientNorm;
  double factr;
  size_t maxLineSearchTrials;
  double minStep;
  double maxStep;

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

  template<typename FunctionType>
  bool LineSearch(FunctionType& function,
                  double& functionValue,
                  arma::mat& iterate,
                  arma::mat& gradient,
                  arma::mat& newIterateTmp,
                  const arma::mat& searchDirection);

  void SearchDirection(const arma::mat& gradient,
                       const size_t iterationNum,
                       const double scalingFactor,
                       const arma::cube& s,
                       const arma::cube& y,
                       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,
                      arma::cube& s,
                      arma::cube& y);
};

} // namespace optimization
} // namespace mlpack

#include "lbfgs_impl.hpp"

#endif // MLPACK_CORE_OPTIMIZERS_LBFGS_LBFGS_HPP