Fix/check for NA or Infinity when notears is used

causalnex/contrib/__init__.py

@@ -25,3 +25,7 @@
 #
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+__all__ = ["assert_all_finite"]
+
+from .utils.validation import assert_all_finite

causalnex/contrib/utils/validation.py

@@ -0,0 +1,46 @@
+"""Utilities for input validation"""
+
+# Authors: Jean-Baptiste Oger
+
+import numpy as np
+
+def assert_all_finite(
+    X: np.ndarray,
+    allow_nan: bool = False
+    ):
+    """Throw a ValueError if X contains NaN or Infinity.
+
+    Based on Sklearn method to handle NaN & Infinity.
+        @inproceedings{sklearn_api,
+        author    = {Lars Buitinck and Gilles Louppe and Mathieu Blondel and
+                    Fabian Pedregosa and Andreas Mueller and Olivier Grisel and
+                    Vlad Niculae and Peter Prettenhofer and Alexandre Gramfort
+                    and Jaques Grobler and Robert Layton and Jake VanderPlas and
+                    Arnaud Joly and Brian Holt and Ga{\"{e}}l Varoquaux},
+        title     = {{API} design for machine learning software: experiences from the scikit-learn
+                    project},
+        booktitle = {ECML PKDD Workshop: Languages for Data Mining and Machine Learning},
+        year      = {2013},
+        pages = {108--122},
+        }
+
+    Args:
+        X: array
+        allow_nan: bool
+
+    Raises:
+        ValueError: If X contains NaN or Infinity
+    """
+    is_float = X.dtype.kind in 'fc'
+    if is_float and (np.isfinite(np.sum(X))):
+        pass
+    elif is_float:
+        msg_err = "Input contains {} or a value too large for {!r}."
+        if (allow_nan and np.isinf(X).any() or
+                not allow_nan and not np.isfinite(X).all()):
+            type_err = 'infinity' if allow_nan else 'NaN, infinity'
+            raise ValueError(
+                    msg_err.format
+                    (type_err,
+                    X.dtype)
+            )

causalnex/structure/notears.py

@@ -49,6 +49,8 @@
 import scipy.linalg as slin
 import scipy.optimize as sopt
 
+from causalnex.contrib.utils.validation import assert_all_finite
+
 from causalnex.structure.structuremodel import StructureModel
 
 __all__ = ["from_numpy", "from_pandas", "from_numpy_lasso", "from_pandas_lasso"]
@@ -101,6 +103,8 @@ def from_numpy(
 
     # n examples, d properties
     _, d = X.shape
+
+    assert_all_finite(X, allow_nan=False)
 
     bnds = [
         (0, 0)
@@ -162,6 +166,8 @@ def from_numpy_lasso(
     # n examples, d properties
     _, d = X.shape
 
+    assert_all_finite(X, allow_nan=False)
+
     bnds = [
         (0, 0)
         if i == j

tests/contrib/test_validation.py

@@ -0,0 +1,20 @@
+import pytest
+
+import numpy as np
+
+from causalnex.contrib.utils.validation import (
+  assert_all_finite
+)
+
+class TestValidation:
+    def test_array_with_nan_raises_error(self):
+        with pytest.raises(ValueError, match="Input contains NaN, infinity or a value too large for dtype*"):
+          arr = np.ones((1,1))
+          arr[0,0] = np.nan
+          assert_all_finite(arr)
+
+    def test_array_with_inf_raises_error(self):
+        with pytest.raises(ValueError, match="Input contains NaN, infinity or a value too large for dtype*"):
+          arr = np.ones((1,1))
+          arr[0,0] = np.inf
+          assert_all_finite(arr)

tests/structure/test_notears.py

@@ -80,6 +80,22 @@ def test_non_numeric_data_raises_error(self):
         with pytest.raises(ValueError, match="All columns must have numeric data.*"):
             from_pandas(pd.DataFrame(data=["x"], columns=["a"]))
 
+    def test_array_with_nan_raises_error(self):
+        """
+        Providing a data set including nan should result in a Value Error explaining that data contains nan.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError, match="Input contains NaN, infinity or a value too large for dtype*"):            
+            from_pandas(pd.DataFrame(data=[np.nan], columns=["a"]))
+
+    def test_array_with_inf_raises_error(self):
+        """
+        Providing a data set including infinite values should result in a Value Error explaining that data contains infinite values.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError):
+            from_pandas(pd.DataFrame(data=[np.inf], columns=["a"]))
+
     def test_single_iter_gets_converged_fail_warnings(self, train_data_idx):
         """
         With a single iteration on this dataset, learn_structure fails to converge and should give warnings.
@@ -206,6 +222,22 @@ def test_non_numeric_data_raises_error(self):
         with pytest.raises(ValueError, match="All columns must have numeric data.*"):
             from_pandas_lasso(pd.DataFrame(data=["x"], columns=["a"]), 0.1)
 
+    def test_array_with_nan_raises_error(self):
+        """
+        Providing a data set including nan should result in a Value Error explaining that data contains nan.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError):            
+            from_pandas_lasso(pd.DataFrame(data=[np.nan], columns=["a"]), 0.1)
+
+    def test_array_with_inf_raises_error(self):
+        """
+        Providing a data set including infinite values should result in a Value Error explaining that data contains infinite values.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError):
+            from_pandas_lasso(pd.DataFrame(data=[np.inf], columns=["a"]), 0.1)
+
     def test_single_iter_gets_converged_fail_warnings(self, train_data_idx):
         """
         With a single iteration on this dataset, learn_structure fails to converge and should give warnings.
@@ -369,6 +401,22 @@ def test_empty_data_raises_error(self):
         with pytest.raises(ValueError):
             from_numpy(np.empty([0, 5]))
 
+    def test_array_with_nan_raises_error(self):
+        """
+        Providing a data set including nan should result in a Value Error explaining that data contains nan.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError):            
+            from_numpy(np.ones([3, 5])*np.nan)
+
+    def test_array_with_inf_raises_error(self):
+        """
+        Providing a data set including infinite values should result in a Value Error explaining that data contains infinite values.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError):
+            from_numpy(np.ones([3, 5])*np.inf)
+
     def test_single_iter_gets_converged_fail_warnings(self, train_data_idx):
         """
         With a single iteration on this dataset, learn_structure fails to converge and should give warnings.
@@ -489,6 +537,22 @@ def test_empty_data_raises_error(self):
         with pytest.raises(ValueError):
             from_numpy_lasso(np.empty([0, 5]), 0.1)
 
+    def test_array_with_nan_raises_error(self):
+        """
+        Providing a data set including nan should result in a Value Error explaining that data contains nan.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError):            
+            from_numpy_lasso(np.ones([3, 5])*np.nan, 0.1)
+
+    def test_array_with_inf_raises_error(self):
+        """
+        Providing a data set including infinite values should result in a Value Error explaining that data contains infinite values.
+        This error is useful to catch and handle gracefully, because otherwise the user would have empty structures.
+        """
+        with pytest.raises(ValueError):
+            from_numpy_lasso(np.ones([3, 5])*np.inf, 0.1)
+
     def test_single_iter_gets_converged_fail_warnings(self, train_data_idx):
         """
         With a single iteration on this dataset, learn_structure fails to converge and should give warnings.