PRF: Faster encoders thanks to F-order layout (scikit-learn#34392)

Author: cakedev0

doc/whats_new/upcoming_changes/sklearn.preprocessing/34392.efficiency.rst

@@ -0,0 +1,4 @@
+- :class:`preprocessing.OneHotEncoder`, :class:`preprocessing.OrdinalEncoder`,
+  and :class:`preprocessing.TargetEncoder` are now faster by using a
+  Fortran-contiguous memory layout in their encoding paths.
+  By :user:`Arthur Lacote <cakedev0>`.

sklearn/preprocessing/_encoders.py

@@ -204,8 +204,8 @@ def _transform(
         )
         validate_data(self, X=X, reset=False, skip_check_array=True)
 
-        X_int = np.zeros((n_samples, n_features), dtype=int)
-        X_mask = np.ones((n_samples, n_features), dtype=bool)
+        X_int = np.zeros((n_samples, n_features), dtype=int, order="F")
+        X_mask = np.ones((n_samples, n_features), dtype=bool, order="F")
 
         columns_with_unknown = []
         for i in range(n_features):
@@ -1072,9 +1072,9 @@ def transform(self, X):
             X_int[X_int > to_drop] -= 1
             X_mask &= keep_cells
 
-        mask = X_mask.ravel()
         feature_indices = np.cumsum([0] + self._n_features_outs)
-        indices = (X_int + feature_indices[:-1]).ravel()[mask]
+        X_int += feature_indices[:-1]
+        indices = X_int[X_mask].ravel()
 
         indptr = np.empty(n_samples + 1, dtype=int)
         indptr[0] = 0

sklearn/preprocessing/_target_encoder.py

@@ -390,27 +390,31 @@ def fit_transform(self, X, y, **params):
             X_out = np.empty(
                 (X_ordinal.shape[0], X_ordinal.shape[1] * len(self.classes_)),
                 dtype=np.float64,
+                order="F",
             )
         else:
             X_out = np.empty_like(X_ordinal, dtype=np.float64)
 
         for train_idx, test_idx in cv.split(X, y, **routed_params.splitter.split):
-            X_train, y_train = X_ordinal[train_idx, :], y_encoded[train_idx]
+            X_indices = np.ascontiguousarray(train_idx, dtype=np.intp)
+            y_train = y_encoded[train_idx]
             y_train_mean = np.mean(y_train, axis=0)
 
             if self.target_type_ == "multiclass":
                 encodings = self._fit_encoding_multiclass(
-                    X_train,
+                    X_ordinal,
                     y_train,
                     n_categories,
                     y_train_mean,
+                    X_indices=X_indices,
                 )
             else:
                 encodings = self._fit_encoding_binary_or_continuous(
-                    X_train,
+                    X_ordinal,
                     y_train,
                     n_categories,
                     y_train_mean,
+                    X_indices=X_indices,
                 )
             self._transform_X_ordinal(
                 X_out,
@@ -453,6 +457,7 @@ def transform(self, X):
             X_out = np.empty(
                 (X_ordinal.shape[0], X_ordinal.shape[1] * len(self.classes_)),
                 dtype=np.float64,
+                order="F",
             )
         else:
             X_out = np.empty_like(X_ordinal, dtype=np.float64)
@@ -529,7 +534,7 @@ def _fit_encodings_all(self, X, y):
         return X_ordinal, X_known_mask, y, n_categories
 
     def _fit_encoding_binary_or_continuous(
-        self, X_ordinal, y, n_categories, target_mean
+        self, X_ordinal, y, n_categories, target_mean, X_indices=None
     ):
         """Learn target encodings."""
         if self.smooth == "auto":
@@ -540,6 +545,7 @@ def _fit_encoding_binary_or_continuous(
                 n_categories,
                 target_mean,
                 y_variance,
+                X_indices,
             )
         else:
             encodings = _fit_encoding_fast(
@@ -548,10 +554,13 @@ def _fit_encoding_binary_or_continuous(
                 n_categories,
                 self.smooth,
                 target_mean,
+                X_indices,
             )
         return encodings
 
-    def _fit_encoding_multiclass(self, X_ordinal, y, n_categories, target_mean):
+    def _fit_encoding_multiclass(
+        self, X_ordinal, y, n_categories, target_mean, X_indices=None
+    ):
         """Learn multiclass encodings.
 
         Learn encodings for each class (c) then reorder encodings such that
@@ -572,6 +581,7 @@ def _fit_encoding_multiclass(self, X_ordinal, y, n_categories, target_mean):
                 y_class,
                 n_categories,
                 target_mean[i],
+                X_indices=X_indices,
             )
             encodings.extend(encoding)
 

sklearn/preprocessing/_target_encoder_fast.pyx

@@ -1,7 +1,13 @@
 from libc.math cimport isnan
 from libcpp.vector cimport vector
 
-from sklearn.utils._typedefs cimport float32_t, float64_t, int32_t, int64_t
+from sklearn.utils._typedefs cimport (
+    float32_t,
+    float64_t,
+    int32_t,
+    int64_t,
+    intp_t,
+)
 
 import numpy as np
 
@@ -18,11 +24,12 @@ ctypedef fused Y_DTYPE:
 
 
 def _fit_encoding_fast(
-    INT_DTYPE[:, ::1] X_int,
+    INT_DTYPE[::1, :] X_int,
     const Y_DTYPE[:] y,
     int64_t[::1] n_categories,
     double smooth,
     double y_mean,
+    const intp_t[::1] X_indices=None,
 ):
     """Fit a target encoding on X_int and y.
 
@@ -33,9 +40,11 @@ def _fit_encoding_fast(
          categorical attributes in classification and prediction problems"
     """
     cdef:
-        int64_t sample_idx, feat_idx, cat_idx, n_cats
+        intp_t sample_idx, row_idx
+        int64_t feat_idx, cat_idx, n_cats
         INT_DTYPE X_int_tmp
-        int n_samples = X_int.shape[0]
+        bint use_X_indices = X_indices is not None
+        intp_t n_samples
         int n_features = X_int.shape[1]
         double smooth_sum = smooth * y_mean
         int64_t max_n_cats = np.max(n_categories)
@@ -46,6 +55,11 @@ def _fit_encoding_fast(
         # Gives access to encodings without gil
         vector[double*] encoding_vec
 
+    if use_X_indices:
+        n_samples = X_indices.shape[0]
+    else:
+        n_samples = X_int.shape[0]
+
     encoding_vec.resize(n_features)
     for feat_idx in range(n_features):
         current_encoding = np.empty(shape=n_categories[feat_idx], dtype=np.float64)
@@ -61,7 +75,11 @@ def _fit_encoding_fast(
                 counts[cat_idx] = smooth
 
             for sample_idx in range(n_samples):
-                X_int_tmp = X_int[sample_idx, feat_idx]
+                if use_X_indices:
+                    row_idx = X_indices[sample_idx]
+                else:
+                    row_idx = sample_idx
+                X_int_tmp = X_int[row_idx, feat_idx]
                 # -1 are unknown categories, which are not counted
                 if X_int_tmp == -1:
                     continue
@@ -78,11 +96,12 @@ def _fit_encoding_fast(
 
 
 def _fit_encoding_fast_auto_smooth(
-    INT_DTYPE[:, ::1] X_int,
+    INT_DTYPE[::1, :] X_int,
     const Y_DTYPE[:] y,
     int64_t[::1] n_categories,
     double y_mean,
     double y_variance,
+    const intp_t[::1] X_indices=None,
 ):
     """Fit a target encoding on X_int and y with auto smoothing.
 
@@ -92,10 +111,12 @@ def _fit_encoding_fast_auto_smooth(
          categorical attributes in classification and prediction problems"
     """
     cdef:
-        int64_t sample_idx, feat_idx, cat_idx, n_cats
+        intp_t sample_idx, row_idx
+        int64_t feat_idx, cat_idx, n_cats
         INT_DTYPE X_int_tmp
         double diff
-        int n_samples = X_int.shape[0]
+        bint use_X_indices = X_indices is not None
+        intp_t n_samples
         int n_features = X_int.shape[1]
         int64_t max_n_cats = np.max(n_categories)
         double[::1] means = np.empty(max_n_cats, dtype=np.float64)
@@ -107,6 +128,11 @@ def _fit_encoding_fast_auto_smooth(
         # Gives access to encodings without gil
         vector[double*] encoding_vec
 
+    if use_X_indices:
+        n_samples = X_indices.shape[0]
+    else:
+        n_samples = X_int.shape[0]
+
     encoding_vec.resize(n_features)
     for feat_idx in range(n_features):
         current_encoding = np.empty(shape=n_categories[feat_idx], dtype=np.float64)
@@ -129,7 +155,11 @@ def _fit_encoding_fast_auto_smooth(
 
             # first pass to compute the mean
             for sample_idx in range(n_samples):
-                X_int_tmp = X_int[sample_idx, feat_idx]
+                if use_X_indices:
+                    row_idx = X_indices[sample_idx]
+                else:
+                    row_idx = sample_idx
+                X_int_tmp = X_int[row_idx, feat_idx]
 
                 # -1 are unknown categories, which are not counted
                 if X_int_tmp == -1:
@@ -142,7 +172,11 @@ def _fit_encoding_fast_auto_smooth(
 
             # second pass to compute the sum of squared differences
             for sample_idx in range(n_samples):
-                X_int_tmp = X_int[sample_idx, feat_idx]
+                if use_X_indices:
+                    row_idx = X_indices[sample_idx]
+                else:
+                    row_idx = sample_idx
+                X_int_tmp = X_int[row_idx, feat_idx]
                 if X_int_tmp == -1:
                     continue
                 diff = y[sample_idx] - means[X_int_tmp]