Update NullTransformer to make it user friendly

rdt/performance/performance.py

@@ -9,6 +9,42 @@
 
 DATASET_SIZES = [1000, 10000, 100000]
 
+# Additional arguments for transformers
+TRANSFORMER_ARGS = {
+    'BooleanTransformer': {
+        'missing_value_replacement': -1,
+        'model_missing_values': True
+    },
+    'DatetimeTransformer': {
+        'missing_value_replacement': 'mean',
+        'model_missing_values': True
+    },
+    'DatetimeRoundedTransformer': {
+        'missing_value_replacement': 'mean',
+        'model_missing_values': True
+    },
+    'NumericalTransformer': {
+        'missing_value_replacement': 'mean',
+        'model_missing_values': True
+    },
+    'NumericalRoundedBoundedTransformer': {
+        'missing_value_replacement': 'mean',
+        'model_missing_values': True
+    },
+    'NumericalBoundedTransformer': {
+        'missing_value_replacement': 'mean',
+        'model_missing_values': True
+    },
+    'GaussianCopulaTransformer': {
+        'missing_value_replacement': 'mean',
+        'model_missing_values': True
+    },
+    'BayesGMMTransformer': {
+        'missing_value_replacement': 'mean',
+        'model_missing_values': True
+    },
+}
+
 
 def _get_dataset_sizes(data_type):
     """Get a list of (fit_size, transform_size) for each dataset generator.
@@ -50,7 +86,8 @@ def evaluate_transformer_performance(transformer, dataset_generator, verbose=Fal
         pandas.DataFrame:
             The performance test results.
     """
-    transformer_instance = transformer()
+    transformer_args = TRANSFORMER_ARGS.get(transformer.__name__, {})
+    transformer_instance = transformer(**transformer_args)
 
     sizes = _get_dataset_sizes(dataset_generator.DATA_TYPE)
 

rdt/performance/profiling.py

@@ -74,6 +74,7 @@ def profile_transformer(transformer, dataset_generator, transform_size, fit_size
     fit_dataset = pd.Series(dataset_generator.generate(fit_size))
     replace = transform_size > fit_size
     transform_dataset = fit_dataset.sample(transform_size, replace=replace)
+    transformer.columns = ['column']
 
     try:
         fit_time = _profile_time(transformer, 'fit', fit_dataset, copy=True)

rdt/transformers/base.py

@@ -105,14 +105,14 @@ def get_next_transformers(self):
         """
         return self._add_prefix(self.NEXT_TRANSFORMERS)
 
-    def get_input_columns(self):
-        """Return list of input column names for transformer.
+    def get_input_column(self):
+        """Return input column name for transformer.
 
         Returns:
-            list:
-                Input column names.
+            str:
+                Input column name.
         """
-        return self.columns
+        return self.columns[0]
 
     def get_output_columns(self):
         """Return list of column names created in ``transform``.

rdt/transformers/boolean.py

@@ -16,10 +16,10 @@ class BooleanTransformer(BaseTransformer):
     Null values are replaced using a ``NullTransformer``.
 
     Args:
-        nan (int or None):
+        missing_value_replacement (int or None):
             Replace null values with the given value. If ``None``, do not replace them.
             Defaults to ``-1``.
-        null_column (bool):
+        model_missing_values (bool):
             Whether to create a new column to indicate which values were null or not.
             If ``None``, only create a new column when the fit data contains null values.
             If ``True``, always create the new column whether there are null values or not.
@@ -33,9 +33,9 @@ class BooleanTransformer(BaseTransformer):
 
     null_transformer = None
 
-    def __init__(self, nan=-1, null_column=None):
-        self.nan = nan
-        self.null_column = null_column
+    def __init__(self, missing_value_replacement=None, model_missing_values=False):
+        self.missing_value_replacement = missing_value_replacement
+        self.model_missing_values = model_missing_values
 
     def get_output_types(self):
         """Return the output types returned by this transformer.
@@ -47,7 +47,7 @@ def get_output_types(self):
         output_types = {
             'value': 'float',
         }
-        if self.null_transformer and self.null_transformer.creates_null_column():
+        if self.null_transformer and self.null_transformer.creates_model_missing_values():
             output_types['is_null'] = 'float'
 
         return self._add_prefix(output_types)
@@ -59,8 +59,11 @@ def _fit(self, data):
             data (pandas.Series):
                 Data to fit to.
         """
-        self.null_transformer = NullTransformer(self.nan, self.null_column, copy=True)
-        self.null_transformer.fit(data)
+        self.null_transformer = NullTransformer(
+            self.missing_value_replacement,
+            self.model_missing_values
+        )
+        self.null_transformer.fit(data, self.get_input_column())
 
     def _transform(self, data):
         """Transform boolean to float.
@@ -92,7 +95,7 @@ def _reverse_transform(self, data):
         if not isinstance(data, np.ndarray):
             data = data.to_numpy()
 
-        if self.nan is not None:
+        if self.missing_value_replacement is not None:
             data = self.null_transformer.reverse_transform(data)
 
         if isinstance(data, np.ndarray):

rdt/transformers/datetime.py

@@ -15,12 +15,12 @@ class DatetimeTransformer(BaseTransformer):
     Null values are replaced using a ``NullTransformer``.
 
     Args:
-        nan (int, str or None):
+        missing_value_replacement (int, str or None):
             Indicate what to do with the null values. If an integer is given, replace them
             with the given value. If the strings ``'mean'`` or ``'mode'`` are given, replace
             them with the corresponding aggregation. If ``None`` is given, do not replace them.
             Defaults to ``'mean'``.
-        null_column (bool):
+        model_missing_values (bool):
             Whether to create a new column to indicate which values were null or not.
             If ``None``, only create a new column when the data contains null values.
             If ``True``, always create the new column whether there are null values or not.
@@ -45,9 +45,10 @@ class DatetimeTransformer(BaseTransformer):
     null_transformer = None
     divider = None
 
-    def __init__(self, nan='mean', null_column=None, strip_constant=False, datetime_format=None):
-        self.nan = nan
-        self.null_column = null_column
+    def __init__(self, missing_value_replacement=None, model_missing_values=False,
+                 strip_constant=False, datetime_format=None):
+        self.missing_value_replacement = missing_value_replacement
+        self.model_missing_values = model_missing_values
         self.strip_constant = strip_constant
         self.datetime_format = datetime_format
 
@@ -58,7 +59,7 @@ def is_composition_identity(self):
             bool:
                 Whether or not transforming and then reverse transforming returns the input data.
         """
-        if self.null_transformer and not self.null_transformer.creates_null_column():
+        if self.null_transformer and not self.null_transformer.creates_model_missing_values():
             return False
 
         return self.COMPOSITION_IS_IDENTITY
@@ -73,7 +74,7 @@ def get_output_types(self):
         output_types = {
             'value': 'float',
         }
-        if self.null_transformer and self.null_transformer.creates_null_column():
+        if self.null_transformer and self.null_transformer.creates_model_missing_values():
             output_types['is_null'] = 'float'
 
         return self._add_prefix(output_types)
@@ -124,8 +125,11 @@ def _fit(self, data):
                 Data to fit the transformer to.
         """
         transformed = self._transform_helper(data)
-        self.null_transformer = NullTransformer(self.nan, self.null_column, copy=True)
-        self.null_transformer.fit(transformed)
+        self.null_transformer = NullTransformer(
+            self.missing_value_replacement,
+            self.model_missing_values
+        )
+        self.null_transformer.fit(transformed, self.get_input_column())
 
     def _transform(self, data):
         """Transform datetime values to float values.
@@ -153,7 +157,7 @@ def _reverse_transform(self, data):
         if not isinstance(data, np.ndarray):
             data = data.to_numpy()
 
-        if self.nan is not None:
+        if self.missing_value_replacement is not None:
             data = self.null_transformer.reverse_transform(data)
 
         if isinstance(data, np.ndarray) and (data.ndim == 2):
@@ -180,18 +184,19 @@ class DatetimeRoundedTransformer(DatetimeTransformer):
     This class behaves exactly as the ``DatetimeTransformer`` with ``strip_constant=True``.
 
     Args:
-        nan (int, str or None):
+        missing_value_replacement (int, str or None):
             Indicate what to do with the null values. If an integer is given, replace them
             with the given value. If the strings ``'mean'`` or ``'mode'`` are given, replace
             them with the corresponding aggregation. If ``None`` is given, do not replace them.
             Defaults to ``'mean'``.
-        null_column (bool):
+        model_missing_values (bool):
             Whether to create a new column to indicate which values were null or not.
             If ``None``, only create a new column when the data contains null values.
             If ``True``, always create the new column whether there are null values or not.
             If ``False``, do not create the new column.
             Defaults to ``None``.
     """
 
-    def __init__(self, nan='mean', null_column=None):
-        super().__init__(nan=nan, null_column=null_column, strip_constant=True)
+    def __init__(self, missing_value_replacement=None, model_missing_values=False):
+        super().__init__(missing_value_replacement=missing_value_replacement,
+                         model_missing_values=model_missing_values, strip_constant=True)