[mlpack-svn] r17307 - mlpack/trunk/src/mlpack/methods/amf/termination_policies

[fastlab-svn at coffeetalk-1.cc.gatech.edu]

Author: rcurtin
Date: Thu Nov  6 00:41:27 2014
New Revision: 17307

Log:
Refactor code for better comments and better adherence to coding conventions.
No functionality change.


Modified:
   mlpack/trunk/src/mlpack/methods/amf/termination_policies/complete_incremental_termination.hpp

Modified: mlpack/trunk/src/mlpack/methods/amf/termination_policies/complete_incremental_termination.hpp
==============================================================================
--- mlpack/trunk/src/mlpack/methods/amf/termination_policies/complete_incremental_termination.hpp	(original)
+++ mlpack/trunk/src/mlpack/methods/amf/termination_policies/complete_incremental_termination.hpp	Thu Nov  6 00:41:27 2014
@@ -4,19 +4,19 @@
  *
  * Termination policy used in AMF (Alternating Matrix Factorization).
  */
-#ifndef _MLPACK_METHODS_AMF_COMPLETE_INCREMENTAL_TERMINATION_HPP_INCLUDED
-#define _MLPACK_METHODS_AMF_COMPLETE_INCREMENTAL_TERMINATION_HPP_INCLUDED
+#ifndef __MLPACK_METHODS_AMF_COMPLETE_INCREMENTAL_TERMINATION_HPP
+#define __MLPACK_METHODS_AMF_COMPLETE_INCREMENTAL_TERMINATION_HPP
 
-namespace mlpack
-{
-namespace amf
-{
+namespace mlpack {
+namespace amf {
 
 /**
- * This class acts as a wrapper for basic termination policies to be used by 
+ * This class acts as a wrapper for basic termination policies to be used by
  * SVDCompleteIncrementalLearning. This class calls the wrapped class functions
  * after every n calls to main class functions where n is the number of non-zero
- * entries in the matrix being factorized. 
+ * entries in the matrix being factorized. This is necessary for
+ * SVDCompleteIncrementalLearning, because otherwise IsConverged() is called
+ * after every point, which is very slow.
  *
  * @see AMF, SVDCompleteIncrementalLearning
  */
@@ -25,12 +25,12 @@
 {
  public:
   /**
-   * Empty constructor
+   * Empty constructor.
    *
-   * @param t_policy object of wrapped class.
+   * @param tPolicy object of wrapped class.
    */
-  CompleteIncrementalTermination(TerminationPolicy t_policy = TerminationPolicy())
-            : t_policy(t_policy) {}
+  CompleteIncrementalTermination(TerminationPolicy tPolicy = TerminationPolicy())
+      : tPolicy(tPolicy) { }
 
   /**
    * Initializes the termination policy before stating the factorization.
@@ -40,73 +40,77 @@
   template <class MatType>
   void Initialize(const MatType& V)
   {
-    t_policy.Initialize(V);
+    tPolicy.Initialize(V);
 
-    //! get number of non-zero entries
-    incrementalIndex = accu(V != 0);
+    // Get the number of non-zero entries.
+    incrementalIndex = arma::accu(V != 0);
     iteration = 0;
   }
 
   /**
-   * Initializes the termination policy before stating the factorization.
+   * Initializes the termination policy before stating the factorization.  This
+   * is a specialization for sparse matrices.
    *
    * @param V Input matrix to be factorized.
    */
   void Initialize(const arma::sp_mat& V)
   {
-    t_policy.Initialize(V);
+    tPolicy.Initialize(V);
 
-    // get number of non-zero entries
+    // Get number of non-zero entries
     incrementalIndex = V.n_nonzero;
     iteration = 0;
   }
 
   /**
-   * Check if termination criterio is met.
+   * Check if termination criterion is met, if the current iteration means that
+   * each point has been visited.
    *
    * @param W Basis matrix of output.
    * @param H Encoding matrix of output.
    */
   bool IsConverged(arma::mat& W, arma::mat& H)
   {
-    // increment iteration count
+    // Increment iteration count.
     iteration++;
-    
-    // if iteration count is multiple of incremental index,
-    // return wrapped class function
-    if(iteration % incrementalIndex == 0)
-      return t_policy.IsConverged(W, H);
-    // else just return false
-    else return false;
+
+    // If iteration count is multiple of incremental index, return wrapped class
+    // function.
+    if (iteration % incrementalIndex == 0)
+      return tPolicy.IsConverged(W, H);
+    else
+      return false;
   }
 
   //! Get current value of residue
-  const double& Index() const { return t_policy.Index(); }
+  const double& Index() const { return tPolicy.Index(); }
 
-  //! Get current iteration count  
+  //! Get current iteration count
   const size_t& Iteration() const { return iteration; }
-  
-  //! Access upper limit of iteration count
-  const size_t& MaxIterations() const { return t_policy.MaxIterations(); }
-  size_t& MaxIterations() { return t_policy.MaxIterations(); }
-  
-  //! Access the wrapped class object
-  const TerminationPolicy& TPolicy() const { return t_policy; }
-  TerminationPolicy& TPolicy() { return t_policy; }
+
+  //! Access upper limit of iteration count.
+  const size_t& MaxIterations() const { return tPolicy.MaxIterations(); }
+  //! Modify maximum number of iterations.
+  size_t& MaxIterations() { return tPolicy.MaxIterations(); }
+
+  //! Access the wrapped termination policy.
+  const TerminationPolicy& TPolicy() const { return tPolicy; }
+  //! Modify the wrapped termination policy.
+  TerminationPolicy& TPolicy() { return tPolicy; }
 
  private:
-  //! wrapped class object
-  TerminationPolicy t_policy;
-  
-  //! number of iterations after which wrapped class object will be called
+  //! Wrapped termination policy.
+  TerminationPolicy tPolicy;
+
+  //! Number of iterations after which wrapped termination policy will be
+  //! called.
   size_t incrementalIndex;
-  //! current iteration count
+  //! Current iteration number.
   size_t iteration;
 }; // class CompleteIncrementalTermination
 
 } // namespace amf
 } // namespace mlpack
 
-
-#endif // COMPLETE_INCREMENTAL_TERMINATION_HPP_INCLUDED
+#endif // __MLPACK_METHODS_AMF_COMPLETE_INCREMENTAL_TERMINATION_HPP