simple_tolerance_termination.hpp

Go to the documentation of this file.

 
#ifndef _MLPACK_METHODS_AMF_SIMPLE_TOLERANCE_TERMINATION_HPP_INCLUDED
#define _MLPACK_METHODS_AMF_SIMPLE_TOLERANCE_TERMINATION_HPP_INCLUDED
 
#include <mlpack/prereqs.hpp>
 
namespace mlpack {
namespace amf {
 
template <class MatType>
class SimpleToleranceTermination
{
 public:
  SimpleToleranceTermination(const double tolerance = 1e-5,
                             const size_t maxIterations = 10000,
                             const size_t reverseStepTolerance = 3) :
      tolerance(tolerance),
      maxIterations(maxIterations),
      V(nullptr),
      iteration(1),
      residueOld(DBL_MAX),
      residue(DBL_MIN),
      reverseStepTolerance(reverseStepTolerance),
      reverseStepCount(0),
      isCopy(false),
      c_indexOld(0),
      c_index(0)
  { }
 
  void Initialize(const MatType& V)
  {
    residueOld = DBL_MAX;
    iteration = 1;
    residue = DBL_MIN;
    reverseStepCount = 0;
    isCopy = false;
 
    this->V = &V;
 
    c_index = 0;
    c_indexOld = 0;
  }
 
  bool IsConverged(arma::mat& W, arma::mat& H)
  {
    arma::mat WH;
 
    WH = W * H;
 
    // compute residue
    residueOld = residue;
    size_t n = V->n_rows;
    size_t m = V->n_cols;
    double sum = 0;
    size_t count = 0;
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < m; ++j)
        {
            double temp = 0;
            if ((temp = (*V)(i, j)) != 0)
            {
                temp = (temp - WH(i, j));
                temp = temp * temp;
                sum += temp;
                count++;
            }
        }
    }
    residue = sum / count;
    residue = sqrt(residue);
 
    // increment iteration count
    iteration++;
    Log::Info << "Iteration " << iteration << "; residue "
        << ((residueOld - residue) / residueOld) << ".\n";
 
    // if residue tolerance is not satisfied
    if ((residueOld - residue) / residueOld < tolerance && iteration > 4)
    {
      // check if this is a first of successive drops
      if (reverseStepCount == 0 && isCopy == false)
      {
        // store a copy of W and H matrix
        isCopy = true;
        this->W = W;
        this->H = H;
        // store residue values
        c_index = residue;
        c_indexOld = residueOld;
      }
      // increase successive drop count
      reverseStepCount++;
    }
    // if tolerance is satisfied
    else
    {
      // initialize successive drop count
      reverseStepCount = 0;
      // if residue is droped below minimum scrap stored values
      if (residue <= c_indexOld && isCopy == true)
      {
        isCopy = false;
      }
    }
 
    // check if termination criterion is met
    if (reverseStepCount == reverseStepTolerance || iteration > maxIterations)
    {
      // if stored values are present replace them with current value as they
      // represent the minimum residue point
      if (isCopy)
      {
        W = this->W;
        H = this->H;
        residue = c_index;
      }
      return true;
    }
    else return false;
  }
 
  const double& Index() const { return residue; }
 
  const size_t& Iteration() const { return iteration; }
 
  const size_t& MaxIterations() const { return maxIterations; }
  size_t& MaxIterations() { return maxIterations; }
 
  const double& Tolerance() const { return tolerance; }
  double& Tolerance() { return tolerance; }
 
 private:
  double tolerance;
  size_t maxIterations;
 
  const MatType* V;
 
  size_t iteration;
 
  double residueOld;
  double residue;
 
  size_t reverseStepTolerance;
  size_t reverseStepCount;
 
  bool isCopy;
 
  arma::mat W;
  arma::mat H;
  double c_indexOld;
  double c_index;
}; // class SimpleToleranceTermination
 
} // namespace amf
} // namespace mlpack
 
#endif // _MLPACK_METHODS_AMF_SIMPLE_TOLERANCE_TERMINATION_HPP_INCLUDED