scikit-learn
diff --git a/‎doc/whats_new/v0.23.rst
Copy file name to clipboardExpand all lines: doc/whats_new/v0.23.rst
+5Lines changed: 5 additions & 0 deletions b/‎doc/whats_new/v0.23.rst
Copy file name to clipboardExpand all lines: doc/whats_new/v0.23.rst
+5Lines changed: 5 additions & 0 deletions
diff --git a/‎sklearn/preprocessing/_encoders.py
Copy file name to clipboardExpand all lines: sklearn/preprocessing/_encoders.py
+46-16Lines changed: 46 additions & 16 deletions b/‎sklearn/preprocessing/_encoders.py
Copy file name to clipboardExpand all lines: sklearn/preprocessing/_encoders.py
+46-16Lines changed: 46 additions & 16 deletions
diff --git a/‎sklearn/preprocessing/tests/test_encoders.py
Copy file name to clipboardExpand all lines: sklearn/preprocessing/tests/test_encoders.py
+39Lines changed: 39 additions & 0 deletions b/‎sklearn/preprocessing/tests/test_encoders.py
Copy file name to clipboardExpand all lines: sklearn/preprocessing/tests/test_encoders.py
+39Lines changed: 39 additions & 0 deletions
@@ -220,6 +220,11 @@ Changelog
 - |Efficiency| :class:`preprocessing.OneHotEncoder` is now faster at
   transforming. :pr:`15762` by `Thomas Fan`_.
 
+- |Feature| argument `drop` of :class:`preprocessing.OneHotEncoder`
+  will now accept value 'if_binary' and will drop the first category of
+  each feature with two categories. :pr:`#16245`
+  by :user:`Rushabh Vasani <rushabh-v>`.
+
 :mod:`sklearn.svm`
 ..................
 
 
@@ -195,6 +195,9 @@ class OneHotEncoder(_BaseEncoder):
         - None : retain all features (the default).
         - 'first' : drop the first category in each feature. If only one
           category is present, the feature will be dropped entirely.
+        - 'if_binary' : drop the first category in each feature with two
+          categories. Features with 1 or more than 2 categories are
+          left intact.
         - array : ``drop[i]`` is the category in feature ``X[:, i]`` that
           should be dropped.
 
@@ -222,8 +225,12 @@ class OneHotEncoder(_BaseEncoder):
 
     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. None if all the transformed features will
-        be retained.
+        be dropped for each feature.
+        ``drop_idx_[i] = -1`` if no category is to be dropped from the feature
+        with index ``i``, e.g. when `drop='if_binary'` and the feature isn't
+        binary
+
+        ``drop_idx_ = None`` if all the transformed features will be retained.
 
     See Also
     --------
@@ -293,15 +300,28 @@ def _validate_keywords(self):
     def _compute_drop_idx(self):
         if self.drop is None:
             return None
-        elif (isinstance(self.drop, str) and self.drop == 'first'):
-            return np.zeros(len(self.categories_), dtype=np.int_)
-        elif not isinstance(self.drop, str):
+        elif isinstance(self.drop, str):
+            if self.drop == 'first':
+                return np.zeros(len(self.categories_), dtype=np.int_)
+            elif self.drop == 'if_binary':
+                return np.array([0 if len(cats) == 2 else -1
+                                for cats in self.categories_], dtype=np.int_)
+            else:
+                msg = (
+                    "Wrong input for parameter `drop`. Expected "
+                    "'first', 'if_binary', None or array of objects, got {}"
+                    )
+                raise ValueError(msg.format(type(self.drop)))
+
+        else:
             try:
                 self.drop = np.asarray(self.drop, dtype=object)
                 droplen = len(self.drop)
             except (ValueError, TypeError):
-                msg = ("Wrong input for parameter `drop`. Expected "
-                       "'first', None or array of objects, got {}")
+                msg = (
+                    "Wrong input for parameter `drop`. Expected "
+                    "'first', 'if_binary', None or array of objects, got {}"
+                    )
                 raise ValueError(msg.format(type(self.drop)))
             if droplen != len(self.categories_):
                 msg = ("`drop` should have length equal to the number "
@@ -321,10 +341,6 @@ def _compute_drop_idx(self):
             return np.array([np.where(cat_list == val)[0][0]
                              for (val, cat_list) in
                              zip(self.drop, self.categories_)], dtype=np.int_)
-        else:
-            msg = ("Wrong input for parameter `drop`. Expected "
-                   "'first', None or array of objects, got {}")
-            raise ValueError(msg.format(type(self.drop)))
 
     def fit(self, X, y=None):
         """
@@ -392,15 +408,25 @@ def transform(self, X):
         n_samples, n_features = X_int.shape
 
         if self.drop is not None:
-            to_drop = self.drop_idx_.reshape(1, -1)
-
+            to_drop = self.drop_idx_.copy()
             # We remove all the dropped categories from mask, and decrement all
             # categories that occur after them to avoid an empty column.
-
             keep_cells = X_int != to_drop
-            X_mask &= keep_cells
+            n_values = []
+            for i, cats in enumerate(self.categories_):
+                n_cats = len(cats)
+
+                # drop='if_binary' but feature isn't binary
+                if to_drop[i] == -1:
+                    # set to cardinality to not drop from X_int
+                    to_drop[i] = n_cats
+                    n_values.append(n_cats)
+                else:  # dropped
+                    n_values.append(n_cats - 1)
+
+            to_drop = to_drop.reshape(1, -1)
             X_int[X_int > to_drop] -= 1
-            n_values = [len(cats) - 1 for cats in self.categories_]
+            X_mask &= keep_cells
         else:
             n_values = [len(cats) for cats in self.categories_]
 
@@ -447,6 +473,10 @@ def inverse_transform(self, X):
         if self.drop is None:
             n_transformed_features = sum(len(cats)
                                          for cats in self.categories_)
+        elif isinstance(self.drop, str) and self.drop == 'if_binary':
+            n_transformed_features = sum(1 if len(cats) == 2
+                                         else len(cats)
+                                         for cats in self.categories_)
         else:
             n_transformed_features = sum(len(cats) - 1
                                          for cats in self.categories_)
 
@@ -265,6 +265,15 @@ def test_one_hot_encoder_inverse(sparse_, drop):
         enc.inverse_transform(X_tr)
 
 
+def test_one_hot_encoder_inverse_if_binary():
+    X = np.array([['Male', 1],
+                  ['Female', 3],
+                  ['Female', 2]], dtype=object)
+    ohe = OneHotEncoder(drop='if_binary', sparse=False)
+    X_tr = ohe.fit_transform(X)
+    assert_array_equal(ohe.inverse_transform(X_tr), X)
+
+
 @pytest.mark.parametrize("method", ['fit', 'fit_transform'])
 @pytest.mark.parametrize("X", [
     [1, 2],
@@ -398,6 +407,36 @@ def test_one_hot_encoder_feature_names_drop(drop, expected_names):
     assert_array_equal(expected_names, feature_names)
 
 
+def test_one_hot_encoder_drop_equals_if_binary():
+    # Canonical case
+    X = [[10, 'yes'],
+         [20, 'no'],
+         [30, 'yes']]
+    expected = np.array([[1., 0., 0., 1.],
+                         [0., 1., 0., 0.],
+                         [0., 0., 1., 1.]])
+    expected_drop_idx = np.array([-1, 0])
+
+    ohe = OneHotEncoder(drop='if_binary', sparse=False)
+    result = ohe.fit_transform(X)
+    assert_array_equal(ohe.drop_idx_, expected_drop_idx)
+    assert_allclose(result, expected)
+
+    # with only one cat, the behaviour is equivalent to drop=None
+    X = [['true', 'a'],
+         ['false', 'a'],
+         ['false', 'a']]
+    expected = np.array([[1., 1.],
+                         [0., 1.],
+                         [0., 1.]])
+    expected_drop_idx = np.array([0, -1])
+
+    ohe = OneHotEncoder(drop='if_binary', sparse=False)
+    result = ohe.fit_transform(X)
+    assert_array_equal(ohe.drop_idx_, expected_drop_idx)
+    assert_allclose(result, expected)
+
+
 @pytest.mark.parametrize("X", [np.array([[1, np.nan]]).T,
                                np.array([['a', np.nan]], dtype=object).T],
                          ids=['numeric', 'object'])