scikit-learn-intelex 2024.1.0__py311-none-win_amd64.whl → 2024.3.0__py311-none-win_amd64.whl

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/preview/covariance/covariance.py

@@ -14,32 +14,47 @@
 # limitations under the License.
 # ===============================================================================
 
+import warnings
+
+import numpy as np
 from scipy import sparse as sp
 from sklearn.covariance import EmpiricalCovariance as sklearn_EmpiricalCovariance
 from sklearn.utils import check_array
 
-from daal4py.sklearn._utils import control_n_jobs, run_with_n_jobs, sklearn_check_version
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
 from onedal.common.hyperparameters import get_hyperparameters
 from onedal.covariance import EmpiricalCovariance as onedal_EmpiricalCovariance
+from sklearnex import config_context
+from sklearnex.metrics import pairwise_distances
 
-from ..._device_offload import dispatch
+from ..._device_offload import dispatch, wrap_output_data
 from ..._utils import PatchingConditionsChain, register_hyperparameters
 
 
 @register_hyperparameters({"fit": get_hyperparameters("covariance", "compute")})
-@control_n_jobs
+@control_n_jobs(decorated_methods=["fit", "mahalanobis"])
 class EmpiricalCovariance(sklearn_EmpiricalCovariance):
     __doc__ = sklearn_EmpiricalCovariance.__doc__
 
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {
+            **sklearn_EmpiricalCovariance._parameter_constraints,
+        }
+
     def _save_attributes(self):
         assert hasattr(self, "_onedal_estimator")
-        self.covariance_ = self._onedal_estimator.covariance_
+        self._set_covariance(self._onedal_estimator.covariance_)
         self.location_ = self._onedal_estimator.location_
 
     _onedal_covariance = staticmethod(onedal_EmpiricalCovariance)
 
-    @run_with_n_jobs
     def _onedal_fit(self, X, queue=None):
+        if X.shape[0] == 1:
+            warnings.warn(
+                "Only one sample available. You may want to reshape your data array"
+            )
+
         onedal_params = {
             "method": "dense",
             "bias": True,
@@ -54,7 +69,7 @@ class EmpiricalCovariance(sklearn_EmpiricalCovariance):
         patching_status = PatchingConditionsChain(
             f"sklearn.covariance.{class_name}.{method_name}"
         )
-        if method_name == "fit":
+        if method_name in ["fit", "mahalanobis"]:
             (X,) = data
             patching_status.and_conditions(
                 [
@@ -62,10 +77,6 @@ class EmpiricalCovariance(sklearn_EmpiricalCovariance):
                         self.assume_centered == False,
                         "assume_centered parameter is not supported on oneDAL side",
                     ),
-                    (
-                        self.store_precision == False,
-                        "precision matrix calculation is not supported on oneDAL side",
-                    ),
                     (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
                 ]
             )
@@ -79,9 +90,9 @@ class EmpiricalCovariance(sklearn_EmpiricalCovariance):
         if sklearn_check_version("1.2"):
             self._validate_params()
         if sklearn_check_version("0.23"):
-            self._validate_data(X)
+            X = self._validate_data(X, force_all_finite=False)
         else:
-            check_array(X)
+            X = check_array(X, force_all_finite=False)
 
         dispatch(
             self,
@@ -95,4 +106,27 @@ class EmpiricalCovariance(sklearn_EmpiricalCovariance):
 
         return self
 
+    # expose sklearnex pairwise_distances if mahalanobis distance eventually supported
+    @wrap_output_data
+    def mahalanobis(self, X):
+        if sklearn_check_version("1.0"):
+            X = self._validate_data(X, reset=False)
+        else:
+            X = check_array(X)
+
+        precision = self.get_precision()
+        with config_context(assume_finite=True):
+            # compute mahalanobis distances
+            dist = pairwise_distances(
+                X, self.location_[np.newaxis, :], metric="mahalanobis", VI=precision
+            )
+
+        return np.reshape(dist, (len(X),)) ** 2
+
+    error_norm = wrap_output_data(sklearn_EmpiricalCovariance.error_norm)
+    score = wrap_output_data(sklearn_EmpiricalCovariance.score)
+
     fit.__doc__ = sklearn_EmpiricalCovariance.fit.__doc__
+    mahalanobis.__doc__ = sklearn_EmpiricalCovariance.mahalanobis
+    error_norm.__doc__ = sklearn_EmpiricalCovariance.error_norm.__doc__
+    score.__doc__ = sklearn_EmpiricalCovariance.score.__doc__

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/spmd/__init__.py

@@ -17,6 +17,7 @@
 __all__ = [
     "basic_statistics",
     "cluster",
+    "covariance",
     "decomposition",
     "ensemble",
     "linear_model",

scikit_learn_intelex-2024.3.0.data/data/Lib/site-packages/sklearnex/spmd/covariance/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from .covariance import EmpiricalCovariance
+
+__all__ = ["EmpiricalCovariance"]

scikit_learn_intelex-2024.3.0.data/data/Lib/site-packages/sklearnex/spmd/covariance/covariance.py

@@ -0,0 +1,21 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from onedal.spmd.covariance import EmpiricalCovariance
+
+# TODO:
+# Currently it uses `onedal` module interface.
+# Add sklearnex dispatching.

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/spmd/ensemble/forest.py

@@ -14,8 +14,6 @@
 # limitations under the License.
 # ==============================================================================
 
-from abc import ABC
-
 from onedal.spmd.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
 from onedal.spmd.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
 
@@ -23,16 +21,9 @@ from ...ensemble import RandomForestClassifier as RandomForestClassifier_Batch
 from ...ensemble import RandomForestRegressor as RandomForestRegressor_Batch
 
 
-class BaseForestSPMD(ABC):
-    def _onedal_classifier(self, **onedal_params):
-        return onedal_RandomForestClassifier(**onedal_params)
-
-    def _onedal_regressor(self, **onedal_params):
-        return onedal_RandomForestRegressor(**onedal_params)
-
-
-class RandomForestClassifier(BaseForestSPMD, RandomForestClassifier_Batch):
+class RandomForestClassifier(RandomForestClassifier_Batch):
     __doc__ = RandomForestClassifier_Batch.__doc__
+    _onedal_factory = onedal_RandomForestClassifier
 
     def _onedal_cpu_supported(self, method_name, *data):
         # TODO:
@@ -55,8 +46,9 @@ class RandomForestClassifier(BaseForestSPMD, RandomForestClassifier_Batch):
         return ready
 
 
-class RandomForestRegressor(BaseForestSPMD, RandomForestRegressor_Batch):
+class RandomForestRegressor(RandomForestRegressor_Batch):
     __doc__ = RandomForestRegressor_Batch.__doc__
+    _onedal_factory = onedal_RandomForestRegressor
 
     def _onedal_cpu_supported(self, method_name, *data):
         # TODO:

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/__init__.py

@@ -15,5 +15,6 @@
 # ==============================================================================
 
 from .linear_model import LinearRegression
+from .logistic_regression import LogisticRegression
 
-__all__ = ["LinearRegression"]
+__all__ = ["LinearRegression", "LogisticRegression"]

scikit_learn_intelex-2024.3.0.data/data/Lib/site-packages/sklearnex/spmd/linear_model/logistic_regression.py

@@ -0,0 +1,21 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from onedal.spmd.linear_model import LogisticRegression
+
+# TODO:
+# Currently it uses `onedal` module interface.
+# Add sklearnex dispatching.

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/svm/nusvc.py

@@ -18,7 +18,8 @@ from sklearn.exceptions import NotFittedError
 from sklearn.svm import NuSVC as sklearn_NuSVC
 from sklearn.utils.validation import _deprecate_positional_args
 
-from daal4py.sklearn._utils import control_n_jobs, run_with_n_jobs, sklearn_check_version
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
 
 from .._device_offload import dispatch, wrap_output_data
 from ._common import BaseSVC
@@ -29,7 +30,9 @@ if sklearn_check_version("1.0"):
 from onedal.svm import NuSVC as onedal_NuSVC
 
 
-@control_n_jobs
+@control_n_jobs(
+    decorated_methods=["fit", "predict", "_predict_proba", "decision_function"]
+)
 class NuSVC(sklearn_NuSVC, BaseSVC):
     __doc__ = sklearn_NuSVC.__doc__
 
@@ -195,6 +198,8 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             self._check_proba()
             return self._predict_proba
 
+        predict_proba.__doc__ = sklearn_NuSVC.predict_proba.__doc__
+
     @wrap_output_data
     def _predict_proba(self, X):
         if sklearn_check_version("1.0"):
@@ -229,7 +234,8 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             X,
         )
 
-    @run_with_n_jobs
+    decision_function.__doc__ = sklearn_NuSVC.decision_function.__doc__
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
             "nu": self.nu,
@@ -253,11 +259,9 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             self._fit_proba(X, y, sample_weight, queue=queue)
         self._save_attributes()
 
-    @run_with_n_jobs
     def _onedal_predict(self, X, queue=None):
         return self._onedal_estimator.predict(X, queue=queue)
 
-    @run_with_n_jobs
     def _onedal_predict_proba(self, X, queue=None):
         if getattr(self, "clf_prob", None) is None:
             raise NotFittedError(
@@ -272,6 +276,5 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
         with config_context(**cfg):
             return self.clf_prob.predict_proba(X)
 
-    @run_with_n_jobs
     def _onedal_decision_function(self, X, queue=None):
         return self._onedal_estimator.decision_function(X, queue=queue)

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/svm/nusvr.py

@@ -17,14 +17,15 @@
 from sklearn.svm import NuSVR as sklearn_NuSVR
 from sklearn.utils.validation import _deprecate_positional_args
 
-from daal4py.sklearn._utils import control_n_jobs, run_with_n_jobs, sklearn_check_version
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import NuSVR as onedal_NuSVR
 
 from .._device_offload import dispatch, wrap_output_data
 from ._common import BaseSVR
 
 
-@control_n_jobs
+@control_n_jobs(decorated_methods=["fit", "predict"])
 class NuSVR(sklearn_NuSVR, BaseSVR):
     __doc__ = sklearn_NuSVR.__doc__
 
@@ -35,14 +36,14 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
     def __init__(
         self,
         *,
+        nu=0.5,
+        C=1.0,
         kernel="rbf",
         degree=3,
         gamma="scale",
         coef0=0.0,
-        tol=1e-3,
-        C=1.0,
-        nu=0.5,
         shrinking=True,
+        tol=1e-3,
         cache_size=200,
         verbose=False,
         max_iter=-1,
@@ -142,7 +143,6 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
             X,
         )
 
-    @run_with_n_jobs
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
             "C": self.C,
@@ -161,6 +161,5 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
         self._onedal_estimator.fit(X, y, sample_weight, queue=queue)
         self._save_attributes()
 
-    @run_with_n_jobs
     def _onedal_predict(self, X, queue=None):
         return self._onedal_estimator.predict(X, queue=queue)

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/svm/svc.py

@@ -20,7 +20,8 @@ from sklearn.exceptions import NotFittedError
 from sklearn.svm import SVC as sklearn_SVC
 from sklearn.utils.validation import _deprecate_positional_args
 
-from daal4py.sklearn._utils import control_n_jobs, run_with_n_jobs, sklearn_check_version
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
@@ -32,7 +33,9 @@ if sklearn_check_version("1.0"):
 from onedal.svm import SVC as onedal_SVC
 
 
-@control_n_jobs
+@control_n_jobs(
+    decorated_methods=["fit", "predict", "_predict_proba", "decision_function"]
+)
 class SVC(sklearn_SVC, BaseSVC):
     __doc__ = sklearn_SVC.__doc__
 
@@ -197,6 +200,8 @@ class SVC(sklearn_SVC, BaseSVC):
             self._check_proba()
             return self._predict_proba
 
+        predict_proba.__doc__ = sklearn_SVC.predict_proba.__doc__
+
     @wrap_output_data
     def _predict_proba(self, X):
         sklearn_pred_proba = (
@@ -229,6 +234,8 @@ class SVC(sklearn_SVC, BaseSVC):
             X,
         )
 
+    decision_function.__doc__ = sklearn_SVC.decision_function.__doc__
+
     def _onedal_gpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
         patching_status = PatchingConditionsChain(
@@ -258,7 +265,6 @@ class SVC(sklearn_SVC, BaseSVC):
             return patching_status
         raise RuntimeError(f"Unknown method {method_name} in {class_name}")
 
-    @run_with_n_jobs
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
             "C": self.C,
@@ -282,11 +288,9 @@ class SVC(sklearn_SVC, BaseSVC):
             self._fit_proba(X, y, sample_weight, queue=queue)
         self._save_attributes()
 
-    @run_with_n_jobs
     def _onedal_predict(self, X, queue=None):
         return self._onedal_estimator.predict(X, queue=queue)
 
-    @run_with_n_jobs
     def _onedal_predict_proba(self, X, queue=None):
         if getattr(self, "clf_prob", None) is None:
             raise NotFittedError(
@@ -301,6 +305,5 @@ class SVC(sklearn_SVC, BaseSVC):
         with config_context(**cfg):
             return self.clf_prob.predict_proba(X)
 
-    @run_with_n_jobs
     def _onedal_decision_function(self, X, queue=None):
         return self._onedal_estimator.decision_function(X, queue=queue)

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/svm/svr.py

@@ -17,14 +17,15 @@
 from sklearn.svm import SVR as sklearn_SVR
 from sklearn.utils.validation import _deprecate_positional_args
 
-from daal4py.sklearn._utils import control_n_jobs, run_with_n_jobs, sklearn_check_version
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import SVR as onedal_SVR
 
 from .._device_offload import dispatch, wrap_output_data
 from ._common import BaseSVR
 
 
-@control_n_jobs
+@control_n_jobs(decorated_methods=["fit", "predict"])
 class SVR(sklearn_SVR, BaseSVR):
     __doc__ = sklearn_SVR.__doc__
 
@@ -143,7 +144,6 @@ class SVR(sklearn_SVR, BaseSVR):
             X,
         )
 
-    @run_with_n_jobs
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
             "C": self.C,
@@ -162,6 +162,5 @@ class SVR(sklearn_SVR, BaseSVR):
         self._onedal_estimator.fit(X, y, sample_weight, queue=queue)
         self._save_attributes()
 
-    @run_with_n_jobs
     def _onedal_predict(self, X, queue=None):
         return self._onedal_estimator.predict(X, queue=queue)

scikit_learn_intelex-2024.3.0.data/data/Lib/site-packages/sklearnex/tests/_utils.py

@@ -0,0 +1,155 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from inspect import isclass
+
+import numpy as np
+from sklearn.base import (
+    BaseEstimator,
+    ClassifierMixin,
+    ClusterMixin,
+    OutlierMixin,
+    RegressorMixin,
+    TransformerMixin,
+)
+from sklearn.datasets import load_diabetes, load_iris
+from sklearn.neighbors._base import KNeighborsMixin
+
+from onedal.tests.utils._dataframes_support import _convert_to_dataframe
+from sklearnex import get_patch_map, patch_sklearn, sklearn_is_patched, unpatch_sklearn
+from sklearnex.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    LocalOutlierFactor,
+    NearestNeighbors,
+)
+from sklearnex.svm import SVC, NuSVC
+
+
+def _load_all_models(with_sklearnex=True, estimator=True):
+    # insure that patch state is correct as dictated by patch_sklearn boolean
+    # and return it to the previous state no matter what occurs.
+    already_patched_map = sklearn_is_patched(return_map=True)
+    already_patched = any(already_patched_map.values())
+    try:
+        if with_sklearnex:
+            patch_sklearn()
+        elif already_patched:
+            unpatch_sklearn()
+
+        models = {}
+        for patch_infos in get_patch_map().values():
+            candidate = getattr(patch_infos[0][0][0], patch_infos[0][0][1], None)
+            if candidate is not None and isclass(candidate) == estimator:
+                if not estimator or issubclass(candidate, BaseEstimator):
+                    models[patch_infos[0][0][1]] = candidate
+    finally:
+        if with_sklearnex:
+            unpatch_sklearn()
+        # both branches are now in an unpatched state, repatch as necessary
+        if already_patched:
+            patch_sklearn(name=[i for i in already_patched_map if already_patched_map[i]])
+
+    return models
+
+
+PATCHED_MODELS = _load_all_models(with_sklearnex=True)
+UNPATCHED_MODELS = _load_all_models(with_sklearnex=False)
+
+PATCHED_FUNCTIONS = _load_all_models(with_sklearnex=True, estimator=False)
+UNPATCHED_FUNCTIONS = _load_all_models(with_sklearnex=False, estimator=False)
+
+mixin_map = [
+    [
+        ClassifierMixin,
+        ["decision_function", "predict", "predict_proba", "predict_log_proba", "score"],
+        "classification",
+    ],
+    [RegressorMixin, ["predict", "score"], "regression"],
+    [ClusterMixin, ["fit_predict"], "classification"],
+    [TransformerMixin, ["fit_transform", "transform", "score"], "classification"],
+    [OutlierMixin, ["fit_predict", "predict"], "classification"],
+    [KNeighborsMixin, ["kneighbors"], None],
+]
+
+
+SPECIAL_INSTANCES = {
+    str(i): i
+    for i in [
+        LocalOutlierFactor(novelty=True),
+        SVC(probability=True),
+        NuSVC(probability=True),
+        KNeighborsClassifier(algorithm="brute"),
+        KNeighborsRegressor(algorithm="brute"),
+        NearestNeighbors(algorithm="brute"),
+    ]
+}
+
+
+def gen_models_info(algorithms):
+    output = []
+    for i in algorithms:
+        # split handles SPECIAL_INSTANCES or custom inputs
+        # custom sklearn inputs must be a dict of estimators
+        # with keys set by the __str__ method
+        est = PATCHED_MODELS[i.split("(")[0]]
+
+        methods = set()
+        candidates = set(
+            [i for i in dir(est) if not i.startswith("_") and not i.endswith("_")]
+        )
+
+        for mixin, method, _ in mixin_map:
+            if issubclass(est, mixin):
+                methods |= candidates & set(method)
+
+        output += [[i, j] for j in methods]
+    return output
+
+
+def gen_dataset(estimator, queue=None, target_df=None, dtype=np.float64):
+    dataset = None
+    name = estimator.__class__.__name__
+    est = PATCHED_MODELS[name]
+    for mixin, _, data in mixin_map:
+        if issubclass(est, mixin) and data is not None:
+            dataset = data
+    # load data
+    if dataset == "classification" or dataset is None:
+        X, y = load_iris(return_X_y=True)
+    elif dataset == "regression":
+        X, y = load_diabetes(return_X_y=True)
+    else:
+        raise ValueError("Unknown dataset type")
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    return X, y
+
+
+DTYPES = [
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.float16,
+    np.float32,
+    np.float64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+]

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
+
 import gc
 import logging
 import tracemalloc
@@ -30,7 +31,6 @@ from sklearn.model_selection import KFold
 from sklearnex import get_patch_map
 from sklearnex.metrics import pairwise_distances, roc_auc_score
 from sklearnex.model_selection import train_test_split
-from sklearnex.preview.decomposition import PCA as PreviewPCA
 from sklearnex.utils import _assert_all_finite
 
 
@@ -75,6 +75,8 @@ class RocAucEstimator:
 
 
 # add all daal4py estimators enabled in patching (except banned)
+
+
 def get_patched_estimators(ban_list, output_list):
     patched_estimators = get_patch_map().values()
     for listing in patched_estimators:
@@ -94,12 +96,8 @@ def remove_duplicated_estimators(estimators_list):
     return estimators_map.values()
 
 
-BANNED_ESTIMATORS = (
-    "LocalOutlierFactor",  # fails on ndarray_c for sklearn > 1.0
-    "TSNE",  # too slow for using in testing on common data size
-)
+BANNED_ESTIMATORS = ("TSNE",)  # too slow for using in testing on common data size
 estimators = [
-    PreviewPCA,
     TrainTestSplitEstimator,
     FiniteCheckEstimator,
     CosineDistancesEstimator,
@@ -156,6 +154,7 @@ def split_train_inference(kf, x, y, estimator):
             y_train, y_test = y.iloc[train_index], y.iloc[test_index]
         # TODO: add parameters for all estimators to prevent
         # fallback to stock scikit-learn with default parameters
+
         alg = estimator()
         alg.fit(x_train, y_train)
         if hasattr(alg, "predict"):
@@ -166,7 +165,6 @@ def split_train_inference(kf, x, y, estimator):
             alg.kneighbors(x_test)
         del alg, x_train, x_test, y_train, y_test
         mem_tracks.append(tracemalloc.get_traced_memory()[0])
-
     return mem_tracks
 
 
@@ -218,6 +216,10 @@ def _kfold_function_template(estimator, data_transform_function, data_shape):
     )
 
 
+# disable fallback check as logging impacts memory use
+
+
+@pytest.mark.allow_sklearn_fallback
 @pytest.mark.parametrize("data_transform_function", data_transforms)
 @pytest.mark.parametrize("estimator", estimators)
 @pytest.mark.parametrize("data_shape", data_shapes)