scikit-learn · trewaite · Oct 24, 2020
diff --git a/sklearn/preprocessing/_encoders.py b/sklearn/preprocessing/_encoders.py
@@ -80,13 +80,19 @@ def _fit(self, X, handle_unknown='error'):
                                  " it has to be of shape (n_features,).")
 
         self.categories_ = []
+        self.categories_count_ = []
 
         for i in range(n_features):
             Xi = X_list[i]
             if self.categories == 'auto':
-                cats = _unique(Xi)
+                cats, cats_count = _unique(Xi, return_counts=True)
             else:
                 cats = np.array(self.categories[i], dtype=Xi.dtype)
+                cats_, cats_count = _unique(Xi, return_counts=True)
+                missing = np.setdiff1d(cats, cats_, assume_unique=True)
+                cats_count = np.append(cats_count, np.zeros(missing.shape[0]))
+                idx = np.argsort(cats)
+                cats_count = cats_count[idx]
                 if Xi.dtype != object:
                     if not np.all(np.sort(cats) == cats):
                         raise ValueError("Unsorted categories are not "
@@ -97,6 +103,7 @@ def _fit(self, X, handle_unknown='error'):
                         msg = ("Found unknown categories {0} in column {1}"
                                " during fit".format(diff, i))
                         raise ValueError(msg)
+            self.categories_count_.append(cats_count)
             self.categories_.append(cats)
 
     def _transform(self, X, handle_unknown='error'):
@@ -205,6 +212,8 @@ class OneHotEncoder(_BaseEncoder):
         - 'if_binary' : drop the first category in each feature with two
           categories. Features with 1 or more than 2 categories are
           left intact.
+        - 'most_frequent' : drop the most frequent category in each feature.
+          If all categories frequency are equal, first category is dropped.
         - array : ``drop[i]`` is the category in feature ``X[:, i]`` that
           should be dropped.
 
@@ -230,6 +239,13 @@ class OneHotEncoder(_BaseEncoder):
         of ``transform``). This includes the category specified in ``drop``
         (if any).
 
+    categories_count_ : list of arrays
+        The frequency count of each category within each feature determined
+        during fitting.
+        (in order of the features in X and corresponding with the output
+        of ``transform``). This includes the category specified in ``drop``
+        (if any).
+
     drop_idx_ : array of shape (n_features,)
         - ``drop_idx_[i]`` is the index in ``categories_[i]`` of the category
           to be dropped for each feature.
@@ -327,10 +343,15 @@ def _compute_drop_idx(self):
                elif self.drop == 'if_binary':
                 return np.array([0 if len(cats) == 2 else None
                                 for cats in self.categories_], dtype=object)
+            elif self.drop == 'most_frequent':
+                return np.array([np.argmax(cats_count)
+                                for cats_count in self.categories_count_],
+                                dtype=object)
             else:
                 msg = (
                     "Wrong input for parameter `drop`. Expected "
-                    "'first', 'if_binary', None or array of objects, got {}"
+                    "'first', 'if_binary', 'most_frequent', None "
+                    "or array of objects, got {}"
                     )
                 raise ValueError(msg.format(type(self.drop)))
 
@@ -341,7 +362,8 @@ def _compute_drop_idx(self):
             except (ValueError, TypeError):
                 msg = (
                     "Wrong input for parameter `drop`. Expected "
-                    "'first', 'if_binary', None or array of objects, got {}"
+                    "'first', 'if_binary', 'most_frequent', None "
+                    "or array of objects, got {}"
                     )
                 raise ValueError(msg.format(type(self.drop)))
             if droplen != len(self.categories_):

diff --git a/sklearn/preprocessing/tests/test_encoders.py b/sklearn/preprocessing/tests/test_encoders.py
@@ -757,3 +757,16 @@ def test_encoders_does_not_support_none_values(Encoder):
     with pytest.raises(TypeError, match="Encoders require their input to be "
                                         "uniformly strings or numbers."):
         Encoder().fit(values)
+
+
+def test_drop_most_frequent():
+    X = [['abc', 12, 2, 55],
+         ['def', 12, 1, 55],
+         ['def', 12, 3, 56]]
+    exp = [[1, 1, 0, 0],
+           [0, 0, 0, 0],
+           [0, 0, 1, 1]]
+    ohe = OneHotEncoder(drop='most_frequent')
+    trans = ohe.fit_transform(X).toarray()
+    assert_array_equal(trans, exp)
+    assert_array_equal(ohe.inverse_transform(trans), np.array(X, dtype=object))
diff --git a/sklearn/utils/_encode.py b/sklearn/utils/_encode.py
@@ -1,7 +1,8 @@
 import numpy as np
+from collections import Counter
 
 
-def _unique(values, *, return_inverse=False):
+def _unique(values, *, return_inverse=False, return_counts=False):
     """Helper function to find unique values with support for python objects.
 
     Uses pure python method for object dtype, and numpy method for
@@ -25,22 +26,32 @@ def _unique(values, *, return_inverse=False):
         Only provided if `return_inverse` is True.
     """
     if values.dtype == object:
-        return _unique_python(values, return_inverse=return_inverse)
+        return _unique_python(values,
+                              return_inverse=return_inverse,
+                              return_counts=return_counts)
     # numerical
-    return np.unique(values, return_inverse=return_inverse)
+    return np.unique(values,
+                     return_inverse=return_inverse,
+                     return_counts=return_counts)
 
 
-def _unique_python(values, *, return_inverse):
+def _unique_python(values, *, return_inverse, return_counts):
     # Only used in `_uniques`, see docstring there for details
     try:
         uniques = sorted(set(values))
-        uniques = np.array(uniques, dtype=values.dtype)
+        if return_counts:
+            ctr = Counter(values)
+            ctr = dict(sorted(ctr.items()))
+            uniques = (np.array(list(ctr.keys()), dtype=values.dtype),
+                       np.array(list(ctr.values()), dtype=values.dtype))
+        else:
+            uniques = np.array(uniques, dtype=values.dtype)
     except TypeError:
         types = sorted(t.__qualname__
                        for t in set(type(v) for v in values))
         raise TypeError("Encoders require their input to be uniformly "
                         f"strings or numbers. Got {types}")
-
+    # TODO
     if return_inverse:
         table = {val: i for i, val in enumerate(uniques)}
         inverse = np.array([table[v] for v in values])