lbfgs_update.hpp

Go to the documentation of this file.

#ifndef STAN__OPTIMIZATION__LBFGS_UPDATE_HPP
#define STAN__OPTIMIZATION__LBFGS_UPDATE_HPP

#include <vector>

#include <boost/tuple/tuple.hpp>
#include <boost/circular_buffer.hpp>

#include <stan/math/matrix/Eigen.hpp>

namespace stan {
  namespace optimization {
    template<typename Scalar = double,
             int DimAtCompile = Eigen::Dynamic>
    class LBFGSUpdate {
    public:
      typedef Eigen::Matrix<Scalar,DimAtCompile,1> VectorT;
      typedef Eigen::Matrix<Scalar,DimAtCompile,DimAtCompile> HessianT;
      typedef boost::tuple<Scalar,VectorT,VectorT> UpdateT;

      LBFGSUpdate(size_t L = 5) : _buf(L) {}

      void set_history_size(size_t L) {
        _buf.rset_capacity(L);
      }

      inline Scalar update(const VectorT &yk, const VectorT &sk,
                           bool reset = false) {
        Scalar skyk = yk.dot(sk);

        Scalar B0fact;
        if (reset) {
          B0fact = yk.squaredNorm()/skyk;
          _buf.clear();
        }
        else {
          B0fact = 1.0;
        }

        // New updates are pushed to the "back" of the circular buffer
        Scalar invskyk = 1.0/skyk;
        _gammak = skyk/yk.squaredNorm();
        _buf.push_back();
        _buf.back() = boost::tie(invskyk,yk,sk);

        return B0fact;
      }

      inline void search_direction(VectorT &pk, const VectorT &gk) const {
        std::vector<Scalar> alphas(_buf.size());
        typename boost::circular_buffer<UpdateT>::const_reverse_iterator buf_rit;
        typename boost::circular_buffer<UpdateT>::const_iterator buf_it;
        typename std::vector<Scalar>::const_iterator alpha_it;
        typename std::vector<Scalar>::reverse_iterator alpha_rit;

        pk.noalias() = -gk;
        for (buf_rit = _buf.rbegin(), alpha_rit = alphas.rbegin();
             buf_rit != _buf.rend();
             buf_rit++, alpha_rit++) {
          Scalar alpha;
          const Scalar &rhoi(boost::get<0>(*buf_rit));
          const VectorT &yi(boost::get<1>(*buf_rit));
          const VectorT &si(boost::get<2>(*buf_rit));

          alpha = rhoi * si.dot(pk);
          pk -= alpha * yi;
          *alpha_rit = alpha;
        }
        pk *= _gammak;
        for (buf_it = _buf.begin(), alpha_it = alphas.begin();
             buf_it != _buf.end();
             buf_it++, alpha_it++) {
          Scalar beta;
          const Scalar &rhoi(boost::get<0>(*buf_it));
          const VectorT &yi(boost::get<1>(*buf_it));
          const VectorT &si(boost::get<2>(*buf_it));

          beta = rhoi*yi.dot(pk);
          pk += (*alpha_it - beta)*si;
        }
      }

    protected:
      boost::circular_buffer<UpdateT> _buf;
      Scalar _gammak;
    };
  }
}

#endif