FEA allow unknowns in OrdinalEncoder transform

sklearn/preprocessing/_encoders.py

@@ -4,6 +4,7 @@
 
 import numpy as np
 from scipy import sparse
+import numbers
 
 from ..base import BaseEstimator, TransformerMixin
 from ..utils import check_array
@@ -115,7 +116,7 @@ def _transform(self, X, handle_unknown='error'):
         for i in range(n_features):
             Xi = X_list[i]
             diff, valid_mask = _check_unknown(Xi, self.categories_[i],
-                                                     return_mask=True)
+                                              return_mask=True)
 
             if not np.all(valid_mask):
                 if handle_unknown == 'error':
@@ -621,6 +622,18 @@ class OrdinalEncoder(_BaseEncoder):
     dtype : number type, default np.float64
         Desired dtype of output.
 
+    handle_unknown : 'error' or 'use_encoded_value', default='error'
+        When set to 'error' an error will be raised in case an unknown
+        categorical feature is present during transform. When set to
+        'use_encoded_value', the encoded value of unknown categories will be
+        set to the value given for the parameter unknown_value. In
+        :meth:inverse_transform, an unknown category will be denoted as None.
+
+    unknown_value : int, default=None
+        When the parameter handle_unknown is set to 'use_encoded_value', this
+        parameter is mandatory and will set the encoded value of unknown
+        categories.
+
     Attributes
     ----------
     categories_ : list of arrays
@@ -657,9 +670,12 @@ class OrdinalEncoder(_BaseEncoder):
     """
 
     @_deprecate_positional_args
-    def __init__(self, *, categories='auto', dtype=np.float64):
+    def __init__(self, *, categories='auto', dtype=np.float64,
+                 handle_unknown='error', unknown_value=None):
         self.categories = categories
         self.dtype = dtype
+        self.handle_unknown = handle_unknown
+        self.unknown_value = unknown_value
 
     def fit(self, X, y=None):
         """
@@ -678,6 +694,14 @@ def fit(self, X, y=None):
         -------
         self
         """
+        if self.handle_unknown == 'use_encoded_value':
+            if self.unknown_value is None:
+                raise TypeError("Please set unknown_value to an integer "
+                                "value.")
+            if not isinstance(self.unknown_value, numbers.Integral):
+                raise TypeError(f"The used value for unknown_value "
+                                f"{self.unknown_value} is not an integer.")
+
         self._fit(X)
 
         return self
@@ -696,7 +720,17 @@ def transform(self, X):
         X_out : sparse matrix or a 2-d array
             Transformed input.
         """
-        X_int, _ = self._transform(X)
+        X_int, X_mask = self._transform(X, handle_unknown=self.handle_unknown)
+
+        # create separate category for unknown values
+        if self.handle_unknown == 'use_encoded_value':
+            for i in range(len(self.categories_)):
+                if 0 <= self.unknown_value < len(self.categories_[i]):
+                    raise ValueError(f"The used value for unknown_value "
+                                     f"{self.unknown_value} is one of the "
+                                     f"values already used for encoding the "
+                                     f"seen categories.")
+                X_int[~X_mask[:, i], i] = self.unknown_value
         return X_int.astype(self.dtype, copy=False)
 
     def inverse_transform(self, X):
@@ -731,6 +765,13 @@ def inverse_transform(self, X):
 
         for i in range(n_features):
             labels = X[:, i].astype('int64', copy=False)
-            X_tr[:, i] = self.categories_[i][labels]
+            # set unknown values to None
+            if self.handle_unknown == 'use_encoded_value':
+                X_tr[:, i] = np.where(
+                    labels == self.unknown_value, None,
+                    self.categories_[i][np.where(
+                        labels == self.unknown_value, 0, labels)])
+            else:
+                X_tr[:, i] = self.categories_[i][labels]
 
         return X_tr

sklearn/preprocessing/tests/test_encoders.py

@@ -553,6 +553,48 @@ def test_ordinal_encoder_raise_missing(X):
         ohe.transform(X)
 
 
+def test_ordinal_encoder_handle_unknowns():
+    enc = OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-2)
+    X_fit = np.array([['a', 'x'], ['b', 'y'], ['c', 'z']], dtype=object)
+    X_trans = np.array([['c', 'xy'], ['bla', 'y'], ['a', 'x']], dtype=object)
+    enc.fit(X_fit)
+
+    X_trans_enc = enc.transform(X_trans)
+    exp = np.array([[2, -2], [-2, 1], [0, 0]], dtype='int64')
+    assert_array_equal(X_trans_enc, exp)
+
+    X_trans_inv = enc.inverse_transform(X_trans_enc)
+    inv_exp = np.array([['c', None], [None, 'y'], ['a', 'x']], dtype=object)
+    assert_array_equal(X_trans_inv, inv_exp)
+
+
+def test_ordinal_encoder_handle_unknowns_raise_fit():
+    X = np.array([['a', 'x'], ['b', 'y']], dtype=object)
+
+    enc = OrdinalEncoder(handle_unknown='use_encoded_value')
+    msg = ("Please set unknown_value to an integer value.")
+    with pytest.raises(TypeError, match=msg):
+        enc.fit(X)
+
+    enc = OrdinalEncoder(handle_unknown='use_encoded_value',
+                         unknown_value='bla')
+    msg = ("The used value for unknown_value bla is not an integer.")
+    with pytest.raises(TypeError, match=msg):
+        enc.fit(X)
+
+
+def test_ordinal_encoder_handle_unknowns_raise_transform():
+    enc = OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=1)
+    X_fit = np.array([['a', 'x'], ['b', 'y'], ['c', 'z']], dtype=object)
+    X_trans = np.array([['c', 'xy'], ['bla', 'y'], ['a', 'x']], dtype=object)
+    enc.fit(X_fit)
+
+    msg = ("The used value for unknown_value 1 is one of the values already "
+           "used for encoding the seen categories.")
+    with pytest.raises(ValueError, match=msg):
+        enc.transform(X_trans)
+
+
 def test_ordinal_encoder_raise_categories_shape():
 
     X = np.array([['Low', 'Medium', 'High', 'Medium', 'Low']], dtype=object).T