rdt 1.4.2.dev0__tar.gz → 1.5.0__tar.gz

{rdt-1.4.2.dev0 → rdt-1.5.0}/CONTRIBUTING.rst

@@ -175,10 +175,9 @@ class uses. In some cases, integration tests may also be required. More details
 found below.
 
 If the transformer adds a previously unsupported `sdtype` to RDT, then more steps will need
-to be taken for the quality and performance tests. A new `DatasetGenerator` class may need to
-be created for the `sdtype`. You may also need to find a real world dataset containing this
-`sdtype` and request for it to be added. More details for these steps can be found below in
-the `Transformer Performance`_ and `Transformer Quality`_ sections respectively.
+to be taken for performance tests. A new `DatasetGenerator` class may need to be created for
+the `sdtype`. More details for these steps can be found below in the `Transformer Performance`_
+section.
 
 Transformer Validations
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -418,64 +417,6 @@ of the transformer.
 Fix any performance issues that are reported. If there are no errors but performance
 can be improved, this function should be used for reference.
 
-.. _Transformer Quality:
-
-Transformer Quality
-"""""""""""""""""""
-
-To assess the quality of a transformer, we run quality tests that apply the Transformer
-on all the real world datasets that contain the Transformer input sdtype. The quality tests
-look at how well the original correlations are preserved by using transformed data to train
-regression models that predict other columns in the data. We compare the transformer's quality
-results to that of other transformers of the same sdtype.
-
-.. _Adding a Dataset:
-
-Adding a Dataset
-****************
-
-If the transformer you are creating adds a new sdtype, then a dataset with that sdtype may need to
-be added for the quality tests. This only needs to be done if the transformer being added is 
-expected to preserve or expose relationships in the data. This can be done using the following
-steps:
-
-1. Find a dataset containing the sdtype your transformer uses as an input.
-
-2. Test your transformer against this dataset by loading it into a ``DataFrame`` and using the
-   ``get_transformer_regression_scores`` in the ``test_quality`` package::
-
-    from tests.quality.test_quality import get_transformer_regression_scores
-    get_transformer_regression_scores(data, sdtype, dataset_name, [transformer])
-
-3. If the scores are higher than the ``TEST_THRESHOLD`` in the ``test_quality`` package, contact
-   one of the `RDT core contributors`_ on GitHub and ask them to add the dataset. Once this is
-   done, the quality tests should pass.
-
-Validating Quality
-******************
-
-Validate the quality of your transformer using the ``validate_transformer_quality`` function.
-This function returns a ``pandas.DataFrame`` containing the scores attained by the transformer
-on each dataset, how that score compares to average and whether or not it is acceptable.
-
-.. code-block:: Python
-
-   In [1]: from tests.contributing import validate_transformer_quality
-
-   In [2]: results = validate_transformer_quality('rdt.transformers.FrequencyEncoder') # Replace FrequencyEncoder with your transformer
-   Validating Quality Tests for transformer FrequencyEncoder
-
-   SUCCESS: The quality tests were successful.
-
-   In [3]: results
-   Out [3]:
-                     Dataset     Score  Compared To Average  Acceptable
-   0                   adult  0.223325             0.443181        True
-   1      student_placements  0.457490             0.994631        True
-   2  student_placements_pii  0.457490             0.988428        True
-
-Fix any quality issues that are reported.
-
 Finalize Your Transformer
 """""""""""""""""""""""""
 
@@ -496,7 +437,6 @@ above. It also prints a table summarizing the results of all these checks.
    Unit Tests         Yes        The unit tests are correct and run successfully.
    Integration tests  Yes        The integration tests run successfully.
    Performance Tests  Yes        The performance of the transformer is acceptable.
-   Quality tests      Yes        The output data quality is acceptable.
    Clean Repository   Yes        There are no unexpected changes in the repository.
 
    SUCCESS: The Pull Request can be made!
@@ -528,14 +468,8 @@ Summary of Steps to Add a New Transformer
 10. Run the ``validate_transformer_performance`` function and fix any errors reported.
     If there are no errors but performance can be improved, this function should be used for
     reference.
-11. If this transformer is expected to help preserve relationships in the data, run the
-    ``validate_transformer_quality`` function. If the quality is too low, make the
-    necessary enhancements to the transformer.
-12. If the quality tests fail because there is no dataset for the transformer's sdtype,
-    follow the steps in the `Adding a Dataset`_ section to add a real world dataset
-    containing the new sdtype to the quality tests.
-13. Run the ``validate_pull_request`` function as a final check and fix any errors reported.
-14. After all the previous steps pass, all the new and modified files can be committed and pushed
+11. Run the ``validate_pull_request`` function as a final check and fix any errors reported.
+12. After all the previous steps pass, all the new and modified files can be committed and pushed
     to github, and a Pull Request can be submitted. Follow the steps in the
     `Pull Request Guidelines`_ section to submit your Pull Request.
 

{rdt-1.4.2.dev0 → rdt-1.5.0}/HISTORY.md

@@ -1,5 +1,39 @@
 # History
 
+## 1.5.0 - 2023-06-01
+
+This release adds a new parameter called `missing_value_generation` to the initialization of certain transformers to specify how missing values should be created. The parameter can be used in the `FloatFormatter`, `BinaryEncoder`, `UnixTimestampEncoder`, `OptimizedTimestampEncoder`, `GaussianNormalizer` and `ClusterBasedNormalizer`. Additionally, it fixes a bug that was causing every column that had nulls to generate them in the same place.
+
+### Deprecations
+
+* The `model_missing_values` parameter is being deprecated in favor of the new `missing_value_generation` parameter.
+
+### Bugs
+
+* Fix randomization when creating null values - Issue [#639](https://github.com/sdv-dev/RDT/issues/639) by @fealho
+
+### New Features
+
+* Allow a no-op handling strategy for missing values (nulls) - Issue [#644](https://github.com/sdv-dev/RDT/issues/644) by @pvk-developer
+* Add add-on detection for premium transformers - Issue [#646](https://github.com/sdv-dev/RDT/issues/646) by @frances-h
+
+### Maintenance
+
+* Performance tests still fragile - Issue [#641](https://github.com/sdv-dev/RDT/issues/641) by @fealho
+* Investigate removing quality tests - Issue [#642](https://github.com/sdv-dev/RDT/issues/642) by @amontanez24
+
+## 1.4.2 - 2023-05-02
+
+This release fixes a bug that caused datetime and numerical transformers to crash if a column was all NaNs. Additionally, it adds support for Pandas 2.0!
+
+### Bugs
+
+* Numerical & datetime transformers crash if the entire column is null - Issue [#637](https://github.com/sdv-dev/RDT/issues/637) by @fraces-h
+
+### Maintenance
+
+* Remove upper bound for pandas - Issue [#633](https://github.com/sdv-dev/RDT/issues/633) by @pvk-developer
+
 ## 1.4.1 - 2023-04-25
 
 This release patches an issue that prevented the `RegexGenerator` from working with regexes that had a very large number of possible combinations.

{rdt-1.4.2.dev0 → rdt-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rdt
-Version: 1.4.2.dev0
+Version: 1.5.0
 Summary: Reversible Data Transforms
 Home-page: https://github.com/sdv-dev/RDT
 Author: DataCebo, Inc.
@@ -226,6 +226,40 @@ for specific needs.
 
 # History
 
+## 1.5.0 - 2023-06-01
+
+This release adds a new parameter called `missing_value_generation` to the initialization of certain transformers to specify how missing values should be created. The parameter can be used in the `FloatFormatter`, `BinaryEncoder`, `UnixTimestampEncoder`, `OptimizedTimestampEncoder`, `GaussianNormalizer` and `ClusterBasedNormalizer`. Additionally, it fixes a bug that was causing every column that had nulls to generate them in the same place.
+
+### Deprecations
+
+* The `model_missing_values` parameter is being deprecated in favor of the new `missing_value_generation` parameter.
+
+### Bugs
+
+* Fix randomization when creating null values - Issue [#639](https://github.com/sdv-dev/RDT/issues/639) by @fealho
+
+### New Features
+
+* Allow a no-op handling strategy for missing values (nulls) - Issue [#644](https://github.com/sdv-dev/RDT/issues/644) by @pvk-developer
+* Add add-on detection for premium transformers - Issue [#646](https://github.com/sdv-dev/RDT/issues/646) by @frances-h
+
+### Maintenance
+
+* Performance tests still fragile - Issue [#641](https://github.com/sdv-dev/RDT/issues/641) by @fealho
+* Investigate removing quality tests - Issue [#642](https://github.com/sdv-dev/RDT/issues/642) by @amontanez24
+
+## 1.4.2 - 2023-05-02
+
+This release fixes a bug that caused datetime and numerical transformers to crash if a column was all NaNs. Additionally, it adds support for Pandas 2.0!
+
+### Bugs
+
+* Numerical & datetime transformers crash if the entire column is null - Issue [#637](https://github.com/sdv-dev/RDT/issues/637) by @fraces-h
+
+### Maintenance
+
+* Remove upper bound for pandas - Issue [#633](https://github.com/sdv-dev/RDT/issues/633) by @pvk-developer
+
 ## 1.4.1 - 2023-04-25
 
 This release patches an issue that prevented the `RegexGenerator` from working with regexes that had a very large number of possible combinations.

{rdt-1.4.2.dev0 → rdt-1.5.0}/rdt/__init__.py

@@ -5,14 +5,18 @@
 
 __author__ = 'DataCebo, Inc.'
 __email__ = 'info@sdv.dev'
-__version__ = '1.4.2.dev0'
+__version__ = '1.5.0'
 
 
+import sys
+import warnings
+from operator import attrgetter
+
 import numpy as np
 import pandas as pd
+from pkg_resources import iter_entry_points
 
 from rdt import transformers
-from rdt._addons import _find_addons
 from rdt.hyper_transformer import HyperTransformer
 
 __all__ = [
@@ -23,9 +27,6 @@ __all__ = [
 RANDOM_SEED = 42
 
 
-_find_addons(group='rdt_modules', parent_globals=globals())
-
-
 def get_demo(num_rows=5):
     """Generate demo data with multiple sdtypes.
 
@@ -92,3 +93,71 @@ def get_demo(num_rows=5):
             'dollars_spent': dollars_spent
         })
     ], ignore_index=True)
+
+
+def _get_addon_target(addon_path_name):
+    """Find the target object for the add-on.
+
+    Args:
+        addon_path_name (str):
+            The add-on's name. The add-on's name should be the full path of valid Python
+            identifiers (i.e. importable.module:object.attr).
+
+    Returns:
+        tuple:
+            * object:
+                The base module or object the add-on should be added to.
+            * str:
+                The name the add-on should be added to under the module or object.
+    """
+    module_path, _, object_path = addon_path_name.partition(':')
+    module_path = module_path.split('.')
+
+    if module_path[0] != __name__:
+        msg = f"expected base module to be '{__name__}', found '{module_path[0]}'"
+        raise AttributeError(msg)
+
+    target_base = sys.modules[__name__]
+    for submodule in module_path[1:-1]:
+        target_base = getattr(target_base, submodule)
+
+    addon_name = module_path[-1]
+    if object_path:
+        if len(module_path) > 1 and not hasattr(target_base, module_path[-1]):
+            msg = f"cannot add '{object_path}' to unknown submodule '{'.'.join(module_path)}'"
+            raise AttributeError(msg)
+
+        if len(module_path) > 1:
+            target_base = getattr(target_base, module_path[-1])
+
+        split_object = object_path.split('.')
+        addon_name = split_object[-1]
+
+        if len(split_object) > 1:
+            target_base = attrgetter('.'.join(split_object[:-1]))(target_base)
+
+    return target_base, addon_name
+
+
+def _find_addons():
+    """Find and load all RDT add-ons."""
+    group = 'rdt_modules'
+    for entry_point in iter_entry_points(group=group):
+        try:
+            addon = entry_point.load()
+        except Exception:  # pylint: disable=broad-exception-caught
+            msg = f'Failed to load "{entry_point.name}" from "{entry_point.module_name}".'
+            warnings.warn(msg)
+            continue
+
+        try:
+            addon_target, addon_name = _get_addon_target(entry_point.name)
+        except AttributeError as error:
+            msg = f"Failed to set '{entry_point.name}': {error}."
+            warnings.warn(msg)
+            continue
+
+        setattr(addon_target, addon_name, addon)
+
+
+_find_addons()

{rdt-1.4.2.dev0 → rdt-1.5.0}/rdt/performance/datasets/categorical.py

@@ -335,7 +335,7 @@ class UniqueIntegerGenerator(CategoricalGenerator):
                 'memory': 500000.0
             },
             'reverse_transform': {
-                'time': 0.0004,
+                'time': 0.0005,
                 'memory': 1000000.0,
             }
         }
@@ -362,7 +362,7 @@ class UniqueIntegerNaNsGenerator(CategoricalGenerator):
                 'memory': 1000000.0
             },
             'reverse_transform': {
-                'time': 0.0004,
+                'time': 0.0005,
                 'memory': 1000000.0,
             }
         }
@@ -389,7 +389,7 @@ class UniqueStringGenerator(CategoricalGenerator):
                 'memory': 500000.0
             },
             'reverse_transform': {
-                'time': 0.0004,
+                'time': 0.0005,
                 'memory': 1000000.0,
             }
         }

{rdt-1.4.2.dev0 → rdt-1.5.0}/rdt/performance/datasets/pii.py

@@ -36,7 +36,7 @@ class RandomStringGenerator(PIIGenerator):
                 'memory': 500.0
             },
             'reverse_transform': {
-                'time': 2e-05,
+                'time': 3e-05,
                 'memory': 1000.0,
             }
         }
@@ -63,7 +63,7 @@ class RandomStringNaNsGenerator(PIIGenerator):
                 'memory': 1000.0
             },
             'reverse_transform': {
-                'time': 2e-05,
+                'time': 3e-05,
                 'memory': 1000.0,
             }
         }

{rdt-1.4.2.dev0 → rdt-1.5.0}/rdt/performance/performance.py

@@ -11,22 +11,22 @@ DATASET_SIZES = [1000, 10000, 100000]
 TRANSFORMER_ARGS = {
     'BinaryEncoder': {
         'missing_value_replacement': -1,
-        'model_missing_values': True
+        'missing_value_generation': 'from_column'
     },
     'UnixTimestampEncoder': {
-        'model_missing_values': True
+        'missing_value_generation': 'from_column'
     },
     'OptimizedTimestampEncoder': {
-        'model_missing_values': True
+        'missing_value_generation': 'from_column'
     },
     'FloatFormatter': {
-        'model_missing_values': True
+        'missing_value_generation': 'from_column'
     },
     'GaussianNormalizer': {
-        'model_missing_values': True
+        'missing_value_generation': 'from_column'
     },
     'ClusterBasedNormalizer': {
-        'model_missing_values': True
+        'missing_value_generation': 'from_column'
     },
 }
 

{rdt-1.4.2.dev0 → rdt-1.5.0}/rdt/transformers/base.py

@@ -1,6 +1,7 @@
 """BaseTransformer module."""
 import abc
 import contextlib
+import hashlib
 import inspect
 import warnings
 from functools import wraps
@@ -8,6 +9,8 @@ from functools import wraps
 import numpy as np
 import pandas as pd
 
+from rdt.errors import TransformerInputError
+
 
 @contextlib.contextmanager
 def set_random_states(random_states, method_name, set_model_random_state):
@@ -65,21 +68,21 @@ class BaseTransformer:
     INPUT_SDTYPE = None
     SUPPORTED_SDTYPES = None
     IS_GENERATOR = None
-    INITIAL_FIT_STATE = np.random.RandomState(seed=21)
-    INITIAL_TRANSFORM_STATE = np.random.RandomState(seed=80)
-    INITIAL_REVERSE_TRANSFORM_STATE = np.random.RandomState(seed=130)
+    INITIAL_FIT_STATE = np.random.RandomState(42)
 
     columns = None
     column_prefix = None
     output_columns = None
+    random_seed = 42
     missing_value_replacement = None
+    missing_value_generation = None
 
     def __init__(self):
         self.output_properties = {None: {'sdtype': 'float', 'next_transformer': None}}
         self.random_states = {
             'fit': self.INITIAL_FIT_STATE,
-            'transform': self.INITIAL_TRANSFORM_STATE,
-            'reverse_transform': self.INITIAL_REVERSE_TRANSFORM_STATE
+            'transform': None,
+            'reverse_transform': None
         }
 
     def set_random_state(self, state, method_name):
@@ -100,9 +103,41 @@ class BaseTransformer:
 
     def reset_randomization(self):
         """Reset the random state for ``reverse_transform``."""
-        self.set_random_state(self.INITIAL_FIT_STATE, 'fit')
-        self.set_random_state(self.INITIAL_TRANSFORM_STATE, 'transform')
-        self.set_random_state(self.INITIAL_REVERSE_TRANSFORM_STATE, 'reverse_transform')
+        self.random_states = {
+            'fit': self.INITIAL_FIT_STATE,
+            'transform': np.random.RandomState(self.random_seed),
+            'reverse_transform': np.random.RandomState(self.random_seed + 1)
+        }
+
+    @property
+    def model_missing_values(self):
+        """Return whether or not a new column is being used to model missing values."""
+        warnings.warn(
+            "Future versions of RDT will not support the 'model_missing_values' parameter. "
+            "Please switch to using the 'missing_value_generation' parameter instead.",
+            FutureWarning
+        )
+        return self.missing_value_generation == 'from_column'
+
+    def _set_missing_value_generation(self, missing_value_generation):
+        if missing_value_generation not in (None, 'from_column', 'random'):
+            raise TransformerInputError(
+                "'missing_value_generation' must be one of the following values: "
+                "None, 'from_column' or 'random'."
+            )
+
+        self.missing_value_generation = missing_value_generation
+
+    def _set_model_missing_values(self, model_missing_values):
+        warnings.warn(
+            "Future versions of RDT will not support the 'model_missing_values' parameter. "
+            "Please switch to using the 'missing_value_generation' parameter to select your "
+            'strategy.', FutureWarning
+        )
+        if model_missing_values is True:
+            self._set_missing_value_generation('from_column')
+        elif model_missing_values is False:
+            self._set_missing_value_generation('random')
 
     def _set_missing_value_replacement(self, default, missing_value_replacement):
         if missing_value_replacement is None:
@@ -297,7 +332,11 @@ class BaseTransformer:
         keys = args.args[1:]
         defaults = args.defaults or []
         defaults = dict(zip(keys, defaults))
-        instanced = {key: getattr(self, key) for key in keys}
+        instanced = {
+            key: getattr(self, key)
+            for key in keys
+            if key != 'model_missing_values'  # Remove after deprecation
+        }
 
         if defaults == instanced:
             return f'{class_name}()'
@@ -318,6 +357,19 @@ class BaseTransformer:
         """
         raise NotImplementedError()
 
+    def _set_seed(self, data):
+        hash_value = self.get_input_column()
+        for value in data.head(5):
+            hash_value += str(value)
+
+        hash_value = int(hashlib.sha256(hash_value.encode('utf-8')).hexdigest(), 16)
+        self.random_seed = hash_value % ((2 ** 32) - 1)  # maximum value for a seed
+        self.random_states = {
+            'fit': self.INITIAL_FIT_STATE,
+            'transform': np.random.RandomState(self.random_seed),
+            'reverse_transform': np.random.RandomState(self.random_seed + 1)
+        }
+
     @random_state
     def fit(self, data, column):
         """Fit the transformer to a ``column`` of the ``data``.
@@ -329,6 +381,7 @@ class BaseTransformer:
                 Column name. Must be present in the data.
         """
         self._store_columns(column, data)
+        self._set_seed(data)
         columns_data = self._get_columns_data(data, self.columns)
         self._fit(columns_data)
         self._build_output_columns(data)

{rdt-1.4.2.dev0 → rdt-1.5.0}/rdt/transformers/boolean.py

@@ -21,19 +21,31 @@ class BinaryEncoder(BaseTransformer):
             replace them with the most common value.
             Defaults to ``mode``.
         model_missing_values (bool):
-            Whether to create a new column to indicate which values were null or not. The column
-            will be created only if there are null values. If ``True``, create the new column if
-            there are null values. If ``False``, do not create the new column even if there
-            are null values. Defaults to ``False``.
+            **DEPRECATED** Whether to create a new column to indicate which values were null or
+            not. The column will be created only if there are null values. If ``True``, create
+            the new column if there are null values. If ``False``, do not create the new column
+            even if there are null values. Defaults to ``False``.
+        missing_value_generation (str or None):
+            The way missing values are being handled. There are three strategies:
+
+                * ``random``: Randomly generates missing values based on the percentage of
+                  missing values.
+                * ``from_column``: Creates a binary column that describes whether the original
+                  value was missing. Then use it to recreate missing values.
+                * ``None``: Do nothing with the missing values on the reverse transform. Simply
+                  pass whatever data we get through.
     """
 
     INPUT_SDTYPE = 'boolean'
     null_transformer = None
 
-    def __init__(self, missing_value_replacement='mode', model_missing_values=False):
+    def __init__(self, missing_value_replacement='mode', model_missing_values=None,
+                 missing_value_generation='random'):
         super().__init__()
+        self._set_missing_value_generation(missing_value_generation)
         self._set_missing_value_replacement('mode', missing_value_replacement)
-        self.model_missing_values = model_missing_values
+        if model_missing_values is not None:
+            self._set_model_missing_values(model_missing_values)
 
     def _fit(self, data):
         """Fit the transformer to the data.
@@ -44,7 +56,7 @@ class BinaryEncoder(BaseTransformer):
         """
         self.null_transformer = NullTransformer(
             self.missing_value_replacement,
-            self.model_missing_values
+            self.missing_value_generation
         )
         self.null_transformer.fit(data)
         if self.null_transformer.models_missing_values():

{rdt-1.4.2.dev0 → rdt-1.5.0}/rdt/transformers/datetime.py

@@ -22,23 +22,35 @@ class UnixTimestampEncoder(BaseTransformer):
             are given, replace them with the corresponding aggregation.
             Defaults to ``mean``.
         model_missing_values (bool):
-            Whether to create a new column to indicate which values were null or not. The column
-            will be created only if there are null values. If ``True``, create the new column if
-            there are null values. If ``False``, do not create the new column even if there
-            are null values. Defaults to ``False``.
+            **DEPRECATED** Whether to create a new column to indicate which values were null or
+            not. The column will be created only if there are null values. If ``True``, create
+            the new column if there are null values. If ``False``, do not create the new column
+            even if there are null values. Defaults to ``False``.
         datetime_format (str):
             The strftime to use for parsing time. For more information, see
             https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior.
+        missing_value_generation (str or None):
+            The way missing values are being handled. There are three strategies:
+
+                * ``random``: Randomly generates missing values based on the percentage of
+                  missing values.
+                * ``from_column``: Creates a binary column that describes whether the original
+                  value was missing. Then use it to recreate missing values.
+                * ``None``: Do nothing with the missing values on the reverse transform. Simply
+                  pass whatever data we get through.
     """
 
     INPUT_SDTYPE = 'datetime'
     null_transformer = None
 
-    def __init__(self, missing_value_replacement='mean', model_missing_values=False,
-                 datetime_format=None):
+    def __init__(self, missing_value_replacement='mean', model_missing_values=None,
+                 datetime_format=None, missing_value_generation='random'):
         super().__init__()
         self._set_missing_value_replacement('mean', missing_value_replacement)
-        self.model_missing_values = model_missing_values
+        self._set_missing_value_generation(missing_value_generation)
+        if model_missing_values is not None:
+            self._set_model_missing_values(model_missing_values)
+
         self.datetime_format = datetime_format
         self._dtype = None
 
@@ -94,7 +106,7 @@ class UnixTimestampEncoder(BaseTransformer):
         transformed = self._transform_helper(data)
         self.null_transformer = NullTransformer(
             self.missing_value_replacement,
-            self.model_missing_values
+            self.missing_value_generation
         )
         self.null_transformer.fit(transformed)
         if self.null_transformer.models_missing_values():
@@ -156,20 +168,30 @@ class OptimizedTimestampEncoder(UnixTimestampEncoder):
             are given, replace them with the corresponding aggregation.
             Defaults to ``mean``.
         model_missing_values (bool):
-            Whether to create a new column to indicate which values were null or not. The column
-            will be created only if there are null values. If ``True``, create the new column if
-            there are null values. If ``False``, do not create the new column even if there
-            are null values. Defaults to ``False``.
+            **DEPRECATED** Whether to create a new column to indicate which values were null or
+            not. The column will be created only if there are null values. If ``True``, create
+            the new column if there are null values. If ``False``, do not create the new column
+            even if there are null values. Defaults to ``False``.
         datetime_format (str):
             The strftime to use for parsing time. For more information, see
             https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior.
+        missing_value_generation (str or None):
+            The way missing values are being handled. There are three strategies:
+
+                * ``random``: Randomly generates missing values based on the percentage of
+                  missing values.
+                * ``from_column``: Creates a binary column that describes whether the original
+                  value was missing. Then use it to recreate missing values.
+                * ``None``: Do nothing with the missing values on the reverse transform. Simply
+                  pass whatever data we get through.
     """
 
     divider = None
 
-    def __init__(self, missing_value_replacement=None, model_missing_values=False,
-                 datetime_format=None):
+    def __init__(self, missing_value_replacement=None, model_missing_values=None,
+                 datetime_format=None, missing_value_generation='random'):
         super().__init__(missing_value_replacement=missing_value_replacement,
+                         missing_value_generation=missing_value_generation,
                          model_missing_values=model_missing_values,
                          datetime_format=datetime_format)