xhluca
diff --git a/‎benchmarks/bench_feature_expansions.py
Lines changed: 0 additions & 49 deletions b/‎benchmarks/bench_feature_expansions.py
Lines changed: 0 additions & 49 deletions
diff --git a/‎doc/whats_new/v0.21.rst
Lines changed: 0 additions & 6 deletions b/‎doc/whats_new/v0.21.rst
Lines changed: 0 additions & 6 deletions
diff --git a/‎sklearn/preprocessing/_csr_polynomial_expansion.pyx
Lines changed: 0 additions & 156 deletions b/‎sklearn/preprocessing/_csr_polynomial_expansion.pyx
Lines changed: 0 additions & 156 deletions
diff --git a/‎sklearn/preprocessing/data.py
Lines changed: 22 additions & 53 deletions b/‎sklearn/preprocessing/data.py
Lines changed: 22 additions & 53 deletions
diff --git a/‎sklearn/preprocessing/setup.py
Lines changed: 0 additions & 20 deletions b/‎sklearn/preprocessing/setup.py
Lines changed: 0 additions & 20 deletions
@@ -55,12 +55,6 @@ Support for Python 3.4 and below has been officially dropped.
   of calculating it every time on the fly.
   :issue:`12116` by :user:`Ekaterina Krivich <kiote>` and `Joel Nothman`_.
 
-- |Efficiency| :class:`preprocessing.PolynomialFeatures` now supports compressed
-  sparse row (CSR) matrices as input for degrees 2 and 3. This is typically much
-  faster than the dense case as it scales with matrix density and expansion degree
-  (on the order of density^degree), and is much, much faster than the compressed
-  sparse column (CSC) case. :issue:`12197` by :user:`Andrew Nystrom <awnystrom>`.
-
 - |Efficiency| |API| Speed improvement in :class:`preprocessing.PolynomialFeatures`,
   in the dense case. Also added a new parameter ``order`` which controls output
   order for further speed performances. :issue:`12251` by `Tom Dupre la Tour`_.
 
@@ -33,10 +33,9 @@
 from ..utils.validation import (check_is_fitted, check_random_state,
                                 FLOAT_DTYPES)
 
-from ._csr_polynomial_expansion import _csr_polynomial_expansion
-
 from ._encoders import OneHotEncoder
 
+
 BOUNDS_THRESHOLD = 1e-7
 
 
@@ -1444,71 +1443,41 @@ def transform(self, X):
         ----------
         X : array-like or sparse matrix, shape [n_samples, n_features]
             The data to transform, row by row.
-            Sparse input should preferably be in CSR format (for speed),
-            but must be in CSC format if the degree is 4 or higher.
-
-            If the input matrix is in CSR format and the expansion is of
-            degree 2 or 3, the method described in the work "Leveraging
-            Sparsity to Speed Up Polynomial Feature Expansions of CSR
-            Matrices Using K-Simplex Numbers" by Andrew Nystrom and
-            John Hughes is used, which is much faster than the method
-            used on CSC input.
+            Sparse input should preferably be in CSC format.
 
         Returns
         -------
-        XP : np.ndarray or CSR/CSC sparse matrix, shape [n_samples, NP]
+        XP : np.ndarray or CSC sparse matrix, shape [n_samples, NP]
             The matrix of features, where NP is the number of polynomial
             features generated from the combination of inputs.
         """
         check_is_fitted(self, ['n_input_features_', 'n_output_features_'])
 
-        X = check_array(X, order='F', dtype=FLOAT_DTYPES,
-                        accept_sparse=('csr', 'csc'))
-
+        X = check_array(X, order='F', dtype=FLOAT_DTYPES, accept_sparse='csc')
         n_samples, n_features = X.shape
 
         if n_features != self.n_input_features_:
             raise ValueError("X shape does not match training shape")
 
-        if sparse.isspmatrix_csr(X):
-            if self.degree > 3:
-                return self.transform(X.tocsc()).tocsr()
-            to_stack = []
-            if self.include_bias:
-                to_stack.append(np.ones(shape=(n_samples, 1), dtype=X.dtype))
-            to_stack.append(X)
-            for deg in range(2, self.degree+1):
-                Xp_next = _csr_polynomial_expansion(X.data, X.indices,
-                                                    X.indptr, X.shape[1],
-                                                    self.interaction_only,
-                                                    deg)
-                if Xp_next is None:
-                    break
-                to_stack.append(Xp_next)
-            XP = sparse.hstack(to_stack, format='csr')
-        elif sparse.isspmatrix_csc(X) and self.degree < 4:
-            return self.transform(X.tocsr()).tocsc()
+        combinations = self._combinations(n_features, self.degree,
+                                          self.interaction_only,
+                                          self.include_bias)
+        if sparse.isspmatrix(X):
+            columns = []
+            for comb in combinations:
+                if comb:
+                    out_col = 1
+                    for col_idx in comb:
+                        out_col = X[:, col_idx].multiply(out_col)
+                    columns.append(out_col)
+                else:
+                    columns.append(sparse.csc_matrix(np.ones((X.shape[0], 1))))
+            XP = sparse.hstack(columns, dtype=X.dtype).tocsc()
         else:
-            combinations = self._combinations(n_features, self.degree,
-                                              self.interaction_only,
-                                              self.include_bias)
-            if sparse.isspmatrix(X):
-                columns = []
-                for comb in combinations:
-                    if comb:
-                        out_col = 1
-                        for col_idx in comb:
-                            out_col = X[:, col_idx].multiply(out_col)
-                        columns.append(out_col)
-                    else:
-                        bias = sparse.csc_matrix(np.ones((X.shape[0], 1)))
-                        columns.append(bias)
-                XP = sparse.hstack(columns, dtype=X.dtype).tocsc()
-            else:
-                XP = np.empty((n_samples, self.n_output_features_),
-                              dtype=X.dtype, order=self.order)
-                for i, comb in enumerate(combinations):
-                    XP[:, i] = X[:, comb].prod(1)
+            XP = np.empty((n_samples, self.n_output_features_), dtype=X.dtype,
+                          order=self.order)
+            for i, comb in enumerate(combinations):
+                XP[:, i] = X[:, comb].prod(1)
 
         return XP