Add LogScaler transformer

rdt/transformers/numerical.py

@@ -651,7 +651,7 @@
                 * ``None``: Do nothing with the missing values on the reverse transform. Simply
                   pass whatever data we get through.
          constant (float):
-            The constant to set as the 0-value for the log-based transform. Default to 0
+            The constant to set as the 0-value for the log-based transform. Defaults to 0
             (do not modify the 0-value of the data).
         invert (bool):
             Whether to invert the data with respect to the constant value. If False, do not
@@ -668,12 +668,19 @@
         self,
         missing_value_replacement='mean',
         missing_value_generation='random',
-        constant: float = 0,
+        constant: float = 0.0,
         invert: bool = False,
         learn_rounding_scheme: bool = False,
     ):
-        self.constant = constant
-        self.invert = invert
+        if isinstance(constant, float):
+            self.constant = constant
+        else:
+            raise ValueError('The constant parameter must be a float.')
+        if isinstance(invert, bool):
+            self.invert = invert
+        else:
+            raise ValueError('The invert parameter must be a bool.')
+
         super().__init__(
             missing_value_replacement=missing_value_replacement,
             missing_value_generation=missing_value_generation,
@@ -684,13 +691,13 @@
         column_name = self.get_input_column()
         if self.invert:
             if not all(data < self.constant):
                 raise InvalidDataError(
                     f"Unable to apply a log transform to column '{column_name}' due to constant"
                     ' being too small.'
                 )
         else:
             if not all(data > self.constant):
                 raise InvalidDataError(
                     f"Unable to apply a log transform to column '{column_name}' due to constant"
                     ' being too large.'
                 )
@@ -704,36 +711,37 @@
         else:
             self._validate_data(data)
 
+    def _log_transform(self, data):
+        if self.invert:
+            return np.log(self.constant - data)
+        else:
+            return np.log(data - self.constant)
+
     def _transform(self, data):
         data = super()._transform(data)
 
         if data.ndim > 1:
             self._validate_data(data[:, 0])
-            if self.invert:
-                data[:, 0] = np.log(self.constant - data[:, 0])
-            else:
-                data[:, 0] = np.log(data[:, 0] - self.constant)
+            data[:, 0] = self._log_transform(data[:, 0])
         else:
             self._validate_data(data)
-            if self.invert:
-                data = np.log(self.constant - data)
-            else:
-                data = np.log(data - self.constant)
+            data = self._log_transform(data)
+
         return data
 
+    def _reverse_log(self, data):
+        if self.invert:
+            return self.constant - np.exp(data)
+        else:
+            return np.exp(data) + self.constant
+
     def _reverse_transform(self, data):
         if not isinstance(data, np.ndarray):
             data = data.to_numpy()
 
         if data.ndim > 1:
-            if self.invert:
-                data[:, 0] = self.constant - np.exp(data[:, 0])
-            else:
-                data[:, 0] = np.exp(data[:, 0]) + self.constant
+            data[:, 0] = self._reverse_log(data[:, 0])
         else:
-            if self.invert:
-                data = self.constant - np.exp(data)
-            else:
-                data = np.exp(data) + self.constant
+            data = self._reverse_log(data)
 
         return super()._reverse_transform(data)

tests/integration/test_transformers.py

@@ -26,7 +26,7 @@
     'FloatFormatter': {'missing_value_generation': 'from_column'},
     'GaussianNormalizer': {'missing_value_generation': 'from_column'},
     'ClusterBasedNormalizer': {'missing_value_generation': 'from_column'},
-    'LogScaler': {'constant': INT64_MIN, 'missing_value_generation': 'from_column'},
+    'LogScaler': {'constant': float(INT64_MIN), 'missing_value_generation': 'from_column'},
 }
 
 # Mapping of rdt sdtype to dtype

tests/integration/transformers/test_numerical.py

@@ -565,6 +565,7 @@ def test_out_of_bounds_reverse_transform(self):
 
 class TestLogScaler:
     def test_learn_rounding(self):
+        """Test that transformer learns rounding scheme from data."""
         # Setup
         data = pd.DataFrame({'test': [1.0, np.nan, 1.5]})
         transformer = LogScaler(
@@ -583,6 +584,7 @@ def test_learn_rounding(self):
         np.testing.assert_array_equal(reversed, expected)
 
     def test_missing_value_generation_from_column(self):
+        """Test from_column missing value generation with nans present."""
         # Setup
         data = pd.DataFrame({'test': [1.0, np.nan, 1.5]})
         transformer = LogScaler(
@@ -599,13 +601,14 @@ def test_missing_value_generation_from_column(self):
         np.testing.assert_array_equal(reversed, data)
 
     def test_missing_value_generation_random(self):
+        """Test random missing_value_generation with nans present."""
         # Setup
         data = pd.DataFrame({'test': [1.0, np.nan, 1.5, 1.5]})
         transformer = LogScaler(
             missing_value_generation='random',
             missing_value_replacement='mode',
             invert=True,
-            constant=3,
+            constant=3.0,
         )
         expected = pd.DataFrame({'test': [np.nan, 1.5, 1.5, 1.5]})
 

tests/unit/transformers/test_numerical.py

@@ -1868,7 +1868,7 @@ def test__reverse_transform_missing_value_replacement_missing_value_replacement_
 
 class TestLogScaler:
     def test___init__super_attrs(self):
-        """super() arguments are properly passed and set as attributes."""
+        """Test super() arguments are properly passed and set as attributes."""
         ls = LogScaler(
             missing_value_generation='random',
             learn_rounding_scheme=False,
@@ -1888,6 +1888,14 @@ def test___init__constant(self):
         assert ls_set.constant == 2.5
         assert ls_default.constant == 0.0
 
+    def test__init__validates_constant(self):
+        """Test __init__ validates constat parameter."""
+        # Setup
+        message = 'The constant parameter must be a float.'
+        # Run and Assert
+        with pytest.raises(ValueError, match=message):
+            LogScaler(constant=2)
+
     def test___init__invert(self):
         """Test invert parameter is set as an attribute."""
         # Setup
@@ -1898,6 +1906,14 @@ def test___init__invert(self):
         assert ls_set.invert
         assert not ls_default.invert
 
+    def test__init__validates_invert(self):
+        """Test __init__ validates constat parameter."""
+        # Setup
+        message = 'The invert parameter must be a bool.'
+        # Run and Assert
+        with pytest.raises(ValueError, match=message):
+            LogScaler(invert=2)
+
     def test__validate_data(self):
         """Test the ``_validate_data`` method"""
         # Setup
@@ -1987,7 +2003,7 @@ def test__transform(self):
     def test__transform_invert(self):
         """Test the ``_transform`` method with ``invert=True``"""
         # Setup
-        ls = LogScaler(constant=3, invert=True, missing_value_replacement='from_column')
+        ls = LogScaler(constant=3.0, invert=True, missing_value_replacement='from_column')
         ls._validate_data = Mock()
         ls.null_transformer = NullTransformer(
             missing_value_replacement='mean', missing_value_generation='from_column'
@@ -2027,7 +2043,7 @@ def test__transform_null_values(self):
     def test__transform_null_values_invert(self):
         """Test the ``_transform`` method with ``invert=True``"""
         # Setup
-        ls = LogScaler(constant=3, invert=True, missing_value_replacement='from_column')
+        ls = LogScaler(constant=3.0, invert=True, missing_value_replacement='from_column')
         ls._validate_data = Mock()
         ls.null_transformer = NullTransformer(
             missing_value_replacement='mean', missing_value_generation='from_column'
@@ -2117,7 +2133,7 @@ def test__reverse_transform_invert(self):
             [0, 0, 1.0],
         ]).T
         expected = pd.Series([0.1, 1.0, np.nan])
-        ls = LogScaler(constant=3, invert=True)
+        ls = LogScaler(constant=3.0, invert=True)
         ls.null_transformer = NullTransformer(
             missing_value_replacement='mean',
             missing_value_generation='from_column',
@@ -2158,7 +2174,7 @@ def test__reverse_transform_invert_missing_value_generation(self):
         # Setup
         data = np.array([1.06471, 0.69315, 0])
         expected = pd.Series([0.1, 1.0, 2.0])
-        ls = LogScaler(constant=3, invert=True)
+        ls = LogScaler(constant=3.0, invert=True)
         ls.null_transformer = NullTransformer(None, missing_value_generation='random')
 
         # Run