add inverse_transform to transformers from transformation module (#283)

solegalli · NicoGalli · web-flow · commit 117ea3061ec9 · 2021-07-04T11:31:13.000+02:00
* New inverse methods in transformers * Log inverse test case * More unit tests + reciprocal error fixed in return * #248 changes requested after initial PR * polish PR on inverse_transform * reorders import in outlier init * adds inverse_transform to jupyter demos * make minor changes to log docstrings Co-authored-by: NicoGalli <nicolas.galli@yahoo.com>
diff --git a/examples/transformation/LogTransformer.ipynb b/examples/transformation/LogTransformer.ipynb
diff --git a/examples/transformation/PowerTransformer.ipynb b/examples/transformation/PowerTransformer.ipynb
diff --git a/examples/transformation/ReciprocalTransformer.ipynb b/examples/transformation/ReciprocalTransformer.ipynb
diff --git a/feature_engine/transformation/log.py b/feature_engine/transformation/log.py
@@ -14,10 +14,10 @@
 class LogTransformer(BaseNumericalTransformer):
     """
     The LogTransformer() applies the natural logarithm or the base 10 logarithm to
-    numerical variables. The natural logarithm is logarithm in base e.
+    numerical variables. The natural logarithm is the logarithm in base e.
 
-    The LogTransformer() only works with numerical non-negative values. If the variable
-    contains a zero or a negative value, the transformer will return an error.
+    The LogTransformer() only works with positive values. If the variable
+    contains a zero or a negative value the transformer will return an error.
 
     A list of variables can be passed as an argument. Alternatively, the transformer
     will automatically select and transform all variables of type numeric.
@@ -45,9 +45,11 @@ class LogTransformer(BaseNumericalTransformer):
     fit:
         This transformer does not learn parameters.
     transform:
-        Transforms the variables using log transformation.
+        Transform the variables using the logarithm.
     fit_transform:
         Fit to data, then transform it.
+    inverse_transform:
+        Convert the data back to the original representation.
     """
 
     def __init__(
@@ -66,9 +68,9 @@ def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
         """
         This transformer does not learn parameters.
 
-        Select the numerical variables and determines whether the logarithm
-        can be applied on the selected variables (it checks if the variables
-        are all positive).
+        Selects the numerical variables and determines whether the logarithm
+        can be applied on the selected variables, i.e., it checks that the variables
+        are positive.
 
         Parameters
         ----------
@@ -109,7 +111,7 @@ def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
 
     def transform(self, X: pd.DataFrame) -> pd.DataFrame:
         """
-        Transforms the variables using log transformation.
+        Transform the variables using log transformation.
 
         Parameters
         ----------
@@ -148,6 +150,41 @@ def transform(self, X: pd.DataFrame) -> pd.DataFrame:
 
         return X
 
+    def inverse_transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Convert the data back to the original representation.
+
+        Parameters
+        ----------
+        X: Pandas DataFrame of shape = [n_samples, n_features]
+            The data to be transformed.
+
+        Raises
+        ------
+        TypeError
+            If the input is not a Pandas DataFrame
+        ValueError
+            - If the variable(s) contain null values
+            - If the df has different number of features than the df used in fit()
+            - If some variables contains zero or negative values
+
+        Returns
+        -------
+        X: pandas dataframe
+            The dataframe with the transformed variables.
+        """
+
+        # check input dataframe and if class was fitted
+        X = super().transform(X)
+
+        # inverse_transform
+        if self.base == "e":
+            X.loc[:, self.variables_] = np.exp(X.loc[:, self.variables_])
+        elif self.base == "10":
+            X.loc[:, self.variables_] = np.array(10 ** X.loc[:, self.variables_])
+
+        return X
+
     def _more_tags(self):
         tags_dict = _return_tags()
         # =======  this tests fail because the transformers throw an error
diff --git a/feature_engine/transformation/power.py b/feature_engine/transformation/power.py
@@ -46,6 +46,8 @@ class PowerTransformer(BaseNumericalTransformer):
         Apply the power transformation to the variables.
     fit_transform:
         Fit to data, then transform it.
+    inverse_transform:
+        Convert the data back to the original representation.
     """
 
     def __init__(
@@ -124,3 +126,34 @@ def transform(self, X: pd.DataFrame) -> pd.DataFrame:
         X.loc[:, self.variables_] = np.power(X.loc[:, self.variables_], self.exp)
 
         return X
+
+    def inverse_transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Convert the data back to the original representation.
+
+        Parameters
+        ----------
+        X: Pandas DataFrame of shape = [n_samples, n_features]
+            The data to be transformed.
+
+        Raises
+        ------
+        TypeError
+            If the input is not a Pandas DataFrame
+        ValueError
+            - If the variable(s) contain null values
+            - If the df has different number of features than the df used in fit()
+
+        Returns
+        -------
+        X: pandas Dataframe
+            The dataframe with the power transformed variables.
+        """
+
+        # check input dataframe and if class was fitted
+        X = super().transform(X)
+
+        # inverse_transform
+        X.loc[:, self.variables_] = np.power(X.loc[:, self.variables_], 1 / self.exp)
+
+        return X
diff --git a/feature_engine/transformation/reciprocal.py b/feature_engine/transformation/reciprocal.py
@@ -45,6 +45,8 @@ class ReciprocalTransformer(BaseNumericalTransformer):
         Apply the reciprocal 1 / x transformation.
     fit_transform:
         Fit to data, then transform it.
+    inverse_transform:
+        Convert the data back to the original representation.
     """
 
     def __init__(
@@ -136,6 +138,32 @@ def transform(self, X: pd.DataFrame) -> pd.DataFrame:
 
         return X
 
+    def inverse_transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Convert the data back to the original representation.
+
+        Parameters
+        ----------
+        X: Pandas DataFrame of shape = [n_samples, n_features]
+            The data to be transformed.
+
+        Raises
+        ------
+        TypeError
+            If the input is not a Pandas DataFrame
+        ValueError
+            - If the variable(s) contain null values
+            - If the df has different number of features than the df used in fit()
+            - If some variables contain zero values
+
+        Returns
+        -------
+        X: pandas dataframe
+            The dataframe with the transformed variables.
+        """
+        # inverse_transform
+        return self.transform(X)
+
     def _more_tags(self):
         tags_dict = _return_tags()
         # =======  this tests fail because the transformers throw an error
diff --git a/tests/test_transformation/test_log_transformer.py b/tests/test_transformation/test_log_transformer.py
@@ -24,6 +24,16 @@ def test_log_base_e_plus_automatically_find_variables(df_vartypes):
     # test transform output
     pd.testing.assert_frame_equal(X, transf_df)
 
+    # test inverse_transform
+    Xit = transformer.inverse_transform(X)
+
+    # convert numbers to original format.
+    Xit["Age"] = Xit["Age"].round().astype("int64")
+    Xit["Marks"] = Xit["Marks"].round(1)
+
+    # test
+    pd.testing.assert_frame_equal(Xit, df_vartypes)
+
 
 def test_log_base_10_plus_user_passes_var_list(df_vartypes):
     # test case 2: log base 10, user passes variables
@@ -43,6 +53,15 @@ def test_log_base_10_plus_user_passes_var_list(df_vartypes):
     # test transform output
     pd.testing.assert_frame_equal(X, transf_df)
 
+    # test inverse_transform
+    Xit = transformer.inverse_transform(X)
+
+    # convert numbers to original format.
+    Xit["Age"] = Xit["Age"].round().astype("int64")
+
+    # test
+    pd.testing.assert_frame_equal(Xit, df_vartypes)
+
 
 def test_error_if_base_value_not_allowed():
     with pytest.raises(ValueError):
@@ -85,3 +104,22 @@ def test_non_fitted_error(df_vartypes):
     with pytest.raises(NotFittedError):
         transformer = LogTransformer()
         transformer.transform(df_vartypes)
+
+
+def test_inverse_e_plus_user_passes_var_list(df_vartypes):
+    # test case 7: inverse log, user passes variables
+    transformer = LogTransformer(variables="Age")
+    Xt = transformer.fit_transform(df_vartypes)
+    X = transformer.inverse_transform(Xt)
+
+    # convert floats to int
+    X["Age"] = X["Age"].round().astype("int64")
+
+    # test init params
+    assert transformer.base == "e"
+    assert transformer.variables == "Age"
+    # test fit attr
+    assert transformer.variables_ == ["Age"]
+    assert transformer.n_features_in_ == 5
+    # test transform output
+    pd.testing.assert_frame_equal(X, df_vartypes)
diff --git a/tests/test_transformation/test_power_transformer.py b/tests/test_transformation/test_power_transformer.py
@@ -24,6 +24,16 @@ def test_defo_params_plus_automatically_find_variables(df_vartypes):
     # test transform output
     pd.testing.assert_frame_equal(X, transf_df)
 
+    # inverse transform
+    Xit = transformer.inverse_transform(X)
+
+    # convert numbers to original format.
+    Xit["Age"] = Xit["Age"].round().astype("int64")
+    Xit["Marks"] = Xit["Marks"].round(1)
+
+    # test
+    pd.testing.assert_frame_equal(Xit, df_vartypes)
+
 
 def test_error_if_exp_value_not_allowed():
     with pytest.raises(ValueError):
@@ -49,3 +59,26 @@ def test_non_fitted_error(df_vartypes):
     with pytest.raises(NotFittedError):
         transformer = PowerTransformer()
         transformer.transform(df_vartypes)
+
+
+_exp_ls = [0.001, 0.1, 2, 3, 4, 10]
+
+
+@pytest.mark.parametrize("exp_base", _exp_ls)
+def test_inverse_transform_exp_no_default(exp_base, df_vartypes):
+    transformer = PowerTransformer(exp=exp_base)
+    Xt = transformer.fit_transform(df_vartypes)
+    X = transformer.inverse_transform(Xt)
+
+    # convert numbers to original format.
+    X["Age"] = X["Age"].round().astype("int64")
+    X["Marks"] = X["Marks"].round(1)
+
+    # test init params
+    # assert transformer.exp == 100
+    assert transformer.variables is None
+    # test fit attr
+    assert transformer.variables_ == ["Age", "Marks"]
+    assert transformer.n_features_in_ == 5
+    # test transform output
+    pd.testing.assert_frame_equal(X, df_vartypes)
diff --git a/tests/test_transformation/test_reciprocal_transformer.py b/tests/test_transformation/test_reciprocal_transformer.py
@@ -23,6 +23,16 @@ def test_automatically_find_variables(df_vartypes):
     # test transform output
     pd.testing.assert_frame_equal(X, transf_df)
 
+    # test inverse_transform
+    Xit = transformer.inverse_transform(X)
+
+    # convert numbers to original format.
+    Xit["Age"] = Xit["Age"].round().astype("int64")
+    Xit["Marks"] = Xit["Marks"].round(1)
+
+    # test
+    pd.testing.assert_frame_equal(Xit, df_vartypes)
+
 
 def test_fit_raises_error_if_na_in_df(df_na):
     # test case 2: when dataset contains na, fit method
