added check_input_matrices option to python bindings

HISTORY.md

@@ -1,5 +1,8 @@
 ### mlpack ?.?.?
 ###### ????-??-??
+  * Add "check_input_matrices" option to python bindings that checks
+    for NaN and inf values in all the input matrices (#2787).
+
   * Add Adjusted R squared functionality to R2Score::Evaluate (#2624).
 
   * Disabled all the bindings by default in CMake (#2782).

src/mlpack/bindings/python/mlpack/io.pxd

@@ -38,6 +38,9 @@ cdef extern from "<mlpack/core/util/io.hpp>" namespace "mlpack" nogil:
     @staticmethod
     void ClearSettings() nogil except +
 
+    @staticmethod
+    void CheckInputMatrices() nogil except +
+
 cdef extern from "<mlpack/bindings/python/mlpack/io_util.hpp>" \
     namespace "mlpack::util" nogil:
   void SetParam[T](string, T&) nogil except +

src/mlpack/bindings/python/print_pyx.cpp

@@ -224,6 +224,16 @@ void PrintPYX(const util::BindingDetails& doc,
     cout << "  IO.SetPassed(<const string> '" << d.name << "')" << endl;
   }
 
+  // Checking the type of check_input_matrices parameter.
+  cout << "  if not isinstance(check_input_matrices, bool):" << endl;
+  cout << "    raise TypeError(" <<"\"'check_input_matrices\' must have type "
+      << "\'bool'!\")" << endl;
+  cout << endl;
+
+  // Before calling mlpackMain(), we check input matrices for NaN values if needed.
+  cout << "  if check_input_matrices:" << endl;
+  cout << "    IO.CheckInputMatrices()" << endl;
+
   // Call the method.
   cout << "  # Call the mlpack program." << endl;
   cout << "  mlpackMain()" << endl;

src/mlpack/bindings/python/py_option.hpp

@@ -64,8 +64,10 @@ class PyOption
     data.required = required;
     data.input = input;
     data.loaded = false;
-    // Only "verbose" and "copy_all_inputs" will be persistent.
-    if (identifier == "verbose" || identifier == "copy_all_inputs")
+    // Only "verbose", "copy_all_inputs" and "check_input_matrices"
+    // will be persistent.
+    if (identifier == "verbose" || identifier == "copy_all_inputs" ||
+        identifier == "check_input_matrices")
       data.persistent = true;
     else
       data.persistent = false;

src/mlpack/bindings/python/tests/test_python_binding.py

@@ -1336,5 +1336,101 @@ def testModelForceCopy(self):
     self.assertEqual(output2['model_bw_out'], 20.0)
     self.assertEqual(output3['model_bw_out'], 20.0)
 
+  def testCheckInputMatricesNaN(self):
+    """
+    Checks that an exception is thrown if the input matrix contains
+    NaN values.
+    """
+    x = np.random.rand(100, 5)
+    a = np.random.randint(low=0, high=100)
+    b = np.random.randint(low=0, high=5)
+    x[a][b] = np.nan
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   matrix_in=x,
+                                                   check_input_matrices=True))
+
+    x_vec = np.random.rand(100)
+    a = np.random.randint(low=0, high=100)
+    x_vec[a] = np.nan
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   row_in=x_vec,
+                                                   check_input_matrices=True))
+
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   col_in=x_vec,
+                                                   check_input_matrices=True))
+
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   matrix_and_info_in=x,
+                                                   check_input_matrices=True))
+
+  def testCheckInputMatricesInf(self):
+    """
+    Checks that an exception is thrown if the input matrix contains
+    inf values.
+    """
+    x = np.random.rand(100, 5)
+    a = np.random.randint(low=0, high=100)
+    b = np.random.randint(low=0, high=5)
+    x[a][b] = np.inf
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   matrix_in=x,
+                                                   check_input_matrices=True))
+
+    x_vec = np.random.rand(100)
+    a = np.random.randint(low=0, high=100)
+    x_vec[a] = np.inf
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   row_in=x_vec,
+                                                   check_input_matrices=True))
+
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   col_in=x_vec,
+                                                   check_input_matrices=True))
+
+    self.assertRaises(RuntimeError,
+                      lambda : test_python_binding(string_in="hello",
+                                                   int_in=12,
+                                                   double_in=4.0,
+                                                   mat_req_in=[[1.0]],
+                                                   col_req_in=[1.0],
+                                                   matrix_and_info_in=x,
+                                                   check_input_matrices=True))
+
 if __name__ == '__main__':
   unittest.main()

src/mlpack/core/util/io.cpp

@@ -267,3 +267,47 @@ void IO::ClearSettings()
   GetSingleton().aliases = persistentAliases;
   GetSingleton().functionMap = persistentFunctions;
 }
+
+void IO::CheckInputMatrices()
+{
+  typedef typename std::tuple<data::DatasetInfo, arma::mat> TupleType;
+  std::map<std::string, util::ParamData>::iterator itr;
+
+  for (itr = IO::Parameters().begin(); itr != IO::Parameters().end(); ++itr)
+  {
+    std::string paramName = itr->first;
+    std::string paramType = itr->second.cppType;
+    if (paramType == "arma::mat")
+    {
+      IO::CheckInputMatrix(IO::GetParam<arma::mat>(paramName), paramName);
+    }
+    else if (paramType == "arma::Mat<size_t>")
+    {
+      IO::CheckInputMatrix(
+          IO::GetParam<arma::Mat<size_t>>(paramName), paramName);
+    }
+    else if (paramType == "arma::vec")
+    {
+      IO::CheckInputMatrix(IO::GetParam<arma::vec>(paramName), paramName);
+    }
+    else if (paramType == "arma::Col<size_t>")
+    {
+      IO::CheckInputMatrix(
+          IO::GetParam<arma::Col<size_t>>(paramName), paramName);
+    }
+    else if (paramType == "arma::rowvec")
+    {
+      IO::CheckInputMatrix(IO::GetParam<arma::rowvec>(paramName), paramName);
+    }
+    else if (paramType == "arma::Row<size_t>")
+    {
+      IO::CheckInputMatrix(
+          IO::GetParam<arma::Row<size_t>>(paramName), paramName);
+    }
+    else if (paramType == "TUPLE_TYPE")
+    {
+      IO::CheckInputMatrix(
+        std::get<1>(IO::GetParam<TupleType>(paramName)), paramName);
+    }
+  }
+}

src/mlpack/core/util/io.hpp

@@ -219,6 +219,15 @@ class IO
   template<typename T>
   static T& GetRawParam(const std::string& identifier);
 
+  /**
+   * Utility function for CheckInputMatrices().
+   *
+   * @param matrix Matrix to check.
+   * @param identifier Name of the parameter in question.
+   */
+  template<typename T>
+  static void CheckInputMatrix(const T& matrix, const std::string& identifier);
+
   /**
    * Given two (matrix) parameters, ensure that the first is an in-place copy of
    * the second.  This will generally do nothing (as the bindings already do
@@ -285,6 +294,11 @@ class IO
    */
   static void ClearSettings();
 
+  /**
+   * Checks all input matrices for NaN and inf values, exits if found any.
+   */
+  static void CheckInputMatrices();
+
  private:
   //! Convenience map from alias values to names.
   std::map<char, std::string> aliases;

src/mlpack/core/util/io_impl.hpp

@@ -145,6 +145,18 @@ T& IO::GetRawParam(const std::string& identifier)
   }
 }
 
+template<typename T>
+void IO::CheckInputMatrix(const T& matrix, const std::string& identifier)
+{
+  std::string errMsg1 = "The input " + identifier + " has NaN values.";
+  std::string errMsg2 = "The input " + identifier + " has inf values.";
+
+  if (matrix.has_nan())
+    Log::Fatal << errMsg1 << std::endl;
+  if (matrix.has_inf())
+    Log::Fatal << errMsg2 << std::endl;
+}
+
 } // namespace mlpack
 
 #endif

src/mlpack/core/util/mlpack_main.hpp

@@ -230,6 +230,8 @@ PARAM_FLAG("copy_all_inputs", "If specified, all input parameters will be deep"
     " copied before the method is run.  This is useful for debugging problems "
     "where the input parameters are being modified by the algorithm, but can "
     "slow down the code.", "");
+PARAM_FLAG("check_input_matrices", "If specified, the input matrix is checked for"
+    " NaN and inf values; an exception is thrown if any are found.", "");
 
 // Nothing else needs to be defined---the binding will use mlpackMain() as-is.