simple_residue_termination.hpp

Go to the documentation of this file.

#ifndef _MLPACK_METHODS_AMF_SIMPLERESIDUETERMINATION_HPP_INCLUDED
#define _MLPACK_METHODS_AMF_SIMPLERESIDUETERMINATION_HPP_INCLUDED

#include <mlpack/prereqs.hpp>

namespace mlpack {
namespace amf {

class SimpleResidueTermination
{
 public:
  SimpleResidueTermination(const double minResidue = 1e-5,
                           const size_t maxIterations = 10000)
      : minResidue(minResidue), maxIterations(maxIterations) { }

  template<typename MatType>
  void Initialize(const MatType& V)
  {
    // Initialize the things we keep track of.
    residue = DBL_MAX;
    iteration = 1;
    nm = V.n_rows * V.n_cols;
    // Remove history.
    normOld = 0;
  }

  bool IsConverged(arma::mat& W, arma::mat& H)
  {
    // Calculate the norm and compute the residue, but do it by hand, so as to
    // avoid calculating (W*H), which may be very large.
    double norm = 0.0;
    for (size_t j = 0; j < H.n_cols; ++j)
      norm += arma::norm(W * H.col(j), "fro");
    residue = fabs(normOld - norm) / normOld;

    // Store the norm.
    normOld = norm;

    // Increment iteration count
    iteration++;
    Log::Info << "Iteration " << iteration << "; residue " << residue << ".\n";

    // Check if termination criterion is met.
    return (residue < minResidue || iteration > maxIterations);
  }

  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& MinResidue() const { return minResidue; }
  double& MinResidue() { return minResidue; }

public:
  double minResidue;
  size_t maxIterations;

  double residue;
  size_t iteration;
  double normOld;

  size_t nm;
}; // class SimpleResidueTermination

} // namespace amf
} // namespace mlpack


#endif // _MLPACK_METHODS_AMF_SIMPLERESIDUETERMINATION_HPP_INCLUDED