scikit-learn-intelex 2025.4.0__py312-none-win_amd64.whl → 2025.6.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/linear.py

@@ -15,7 +15,6 @@
 # ===============================================================================
 
 import logging
-from abc import ABC
 
 import numpy as np
 from sklearn.linear_model import LinearRegression as _sklearn_LinearRegression
@@ -27,14 +26,11 @@ from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 
 from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import (
-    PatchableEstimator,
-    PatchingConditionsChain,
-    get_patch_message,
-    register_hyperparameters,
-)
-
-if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
+from .._utils import PatchingConditionsChain, get_patch_message, register_hyperparameters
+from ..base import oneDALEstimator
+from ..utils.validation import validate_data
+
+if not sklearn_check_version("1.2"):
     from sklearn.linear_model._base import _deprecate_normalize
 
 from scipy.sparse import issparse
@@ -42,17 +38,12 @@ from sklearn.utils.validation import check_is_fitted, check_X_y
 
 from onedal.common.hyperparameters import get_hyperparameters
 from onedal.linear_model import LinearRegression as onedal_LinearRegression
-from onedal.utils import _num_features, _num_samples
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_LinearRegression._validate_data
+from onedal.utils.validation import _num_features, _num_samples
 
 
 @register_hyperparameters({"fit": get_hyperparameters("linear_regression", "train")})
 @control_n_jobs(decorated_methods=["fit", "predict", "score"])
-class LinearRegression(PatchableEstimator, _sklearn_LinearRegression):
+class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
     __doc__ = _sklearn_LinearRegression.__doc__
 
     if sklearn_check_version("1.2"):
@@ -60,26 +51,46 @@ class LinearRegression(PatchableEstimator, _sklearn_LinearRegression):
             **_sklearn_LinearRegression._parameter_constraints
         }
 
-        def __init__(
-            self,
-            fit_intercept=True,
-            copy_X=True,
-            n_jobs=None,
-            positive=False,
-        ):
-            super().__init__(
-                fit_intercept=fit_intercept,
-                copy_X=copy_X,
-                n_jobs=n_jobs,
-                positive=positive,
-            )
+        if sklearn_check_version("1.7"):
+
+            def __init__(
+                self,
+                fit_intercept=True,
+                copy_X=True,
+                tol=1e-06,  # for sparse solver only, not used by oneDAL
+                n_jobs=None,
+                positive=False,
+            ):
+                super().__init__(
+                    fit_intercept=fit_intercept,
+                    copy_X=copy_X,
+                    tol=tol,
+                    n_jobs=n_jobs,
+                    positive=positive,
+                )
+
+        else:
+
+            def __init__(
+                self,
+                fit_intercept=True,
+                copy_X=True,
+                n_jobs=None,
+                positive=False,
+            ):
+                super().__init__(
+                    fit_intercept=fit_intercept,
+                    copy_X=copy_X,
+                    n_jobs=n_jobs,
+                    positive=positive,
+                )
 
     else:
 
         def __init__(
             self,
             fit_intercept=True,
-            normalize="deprecated" if sklearn_check_version("1.0") else False,
+            normalize="deprecated",
             copy_X=True,
             n_jobs=None,
             positive=False,
@@ -246,20 +257,17 @@ class LinearRegression(PatchableEstimator, _sklearn_LinearRegression):
         assert sample_weight is None
 
         supports_multi_output = daal_check_version((2025, "P", 1))
-        check_params = {
-            "X": X,
-            "y": y,
-            "dtype": [np.float64, np.float32],
-            "accept_sparse": ["csr", "csc", "coo"],
-            "y_numeric": True,
-            "multi_output": supports_multi_output,
-        }
-        if sklearn_check_version("1.0"):
-            X, y = validate_data(self, **check_params)
-        else:
-            X, y = check_X_y(**check_params)
+        X, y = validate_data(
+            self,
+            X=X,
+            y=y,
+            dtype=[np.float64, np.float32],
+            accept_sparse=["csr", "csc", "coo"],
+            y_numeric=True,
+            multi_output=supports_multi_output,
+        )
 
-        if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
+        if not sklearn_check_version("1.2"):
             self._normalize = _deprecate_normalize(
                 self.normalize,
                 default=False,
@@ -287,10 +295,7 @@ class LinearRegression(PatchableEstimator, _sklearn_LinearRegression):
             self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
-        if sklearn_check_version("1.0"):
-            X = validate_data(self, X, accept_sparse=False, reset=False)
-        else:
-            X = check_array(X, accept_sparse=False)
+        X = validate_data(self, X, accept_sparse=False, reset=False)
 
         if not hasattr(self, "_onedal_estimator"):
             self._initialize_onedal_estimator()

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/logistic_regression.py

@@ -34,28 +34,16 @@ if daal_check_version((2024, "P", 1)):
     from daal4py.sklearn._utils import sklearn_check_version
     from daal4py.sklearn.linear_model.logistic_path import daal4py_fit, daal4py_predict
     from onedal.linear_model import LogisticRegression as onedal_LogisticRegression
-    from onedal.utils import _num_samples
+    from onedal.utils.validation import _num_samples
 
     from .._config import get_config
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchableEstimator, PatchingConditionsChain, get_patch_message
-
-    if sklearn_check_version("1.6"):
-        from sklearn.utils.validation import validate_data
-    else:
-        validate_data = _sklearn_LogisticRegression._validate_data
+    from .._utils import PatchingConditionsChain, get_patch_message
+    from ..base import oneDALEstimator
+    from ..utils.validation import validate_data
 
     _sparsity_enabled = daal_check_version((2024, "P", 700))
 
-    class BaseLogisticRegression(ABC):
-        def _onedal_gpu_save_attributes(self):
-            assert hasattr(self, "_onedal_estimator")
-            self.classes_ = self._onedal_estimator.classes_
-            self.coef_ = self._onedal_estimator.coef_
-            self.intercept_ = self._onedal_estimator.intercept_
-            self.n_features_in_ = self._onedal_estimator.n_features_in_
-            self.n_iter_ = self._onedal_estimator.n_iter_
-
     @control_n_jobs(
         decorated_methods=[
             "fit",
@@ -65,9 +53,7 @@ if daal_check_version((2024, "P", 1)):
             "score",
         ]
     )
-    class LogisticRegression(
-        PatchableEstimator, _sklearn_LogisticRegression, BaseLogisticRegression
-    ):
+    class LogisticRegression(oneDALEstimator, _sklearn_LogisticRegression):
         __doc__ = _sklearn_LogisticRegression.__doc__
 
         if sklearn_check_version("1.2"):
@@ -114,6 +100,14 @@ if daal_check_version((2024, "P", 1)):
 
         _onedal_cpu_fit = daal4py_fit
 
+        def _onedal_gpu_save_attributes(self):
+            assert hasattr(self, "_onedal_estimator")
+            self.classes_ = self._onedal_estimator.classes_
+            self.coef_ = self._onedal_estimator.coef_
+            self.intercept_ = self._onedal_estimator.intercept_
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+            self.n_iter_ = self._onedal_estimator.n_iter_
+
         def fit(self, X, y, sample_weight=None):
             if sklearn_check_version("1.2"):
                 self._validate_params()
@@ -293,23 +287,14 @@ if daal_check_version((2024, "P", 1)):
 
             assert sample_weight is None
 
-            if sklearn_check_version("1.0"):
-                X, y = validate_data(
-                    self,
-                    X,
-                    y,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
-            else:
-                X, y = check_X_y(
-                    X,
-                    y,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
+            X, y = validate_data(
+                self,
+                X,
+                y,
+                accept_sparse=_sparsity_enabled,
+                accept_large_sparse=_sparsity_enabled,
+                dtype=[np.float64, np.float32],
+            )
 
             self._onedal_gpu_initialize_estimator()
             try:
@@ -332,22 +317,14 @@ if daal_check_version((2024, "P", 1)):
             if queue is None or queue.sycl_device.is_cpu:
                 return daal4py_predict(self, X, "computeClassLabels")
 
-            if sklearn_check_version("1.0"):
-                X = validate_data(
-                    self,
-                    X,
-                    reset=False,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
-            else:
-                X = check_array(
-                    X,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
+            X = validate_data(
+                self,
+                X,
+                reset=False,
+                accept_sparse=_sparsity_enabled,
+                accept_large_sparse=_sparsity_enabled,
+                dtype=[np.float64, np.float32],
+            )
 
             assert hasattr(self, "_onedal_estimator")
             return self._onedal_estimator.predict(X, queue=queue)
@@ -356,22 +333,14 @@ if daal_check_version((2024, "P", 1)):
             if queue is None or queue.sycl_device.is_cpu:
                 return daal4py_predict(self, X, "computeClassProbabilities")
 
-            if sklearn_check_version("1.0"):
-                X = validate_data(
-                    self,
-                    X,
-                    reset=False,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
-            else:
-                X = check_array(
-                    X,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
+            X = validate_data(
+                self,
+                X,
+                reset=False,
+                accept_sparse=_sparsity_enabled,
+                accept_large_sparse=_sparsity_enabled,
+                dtype=[np.float64, np.float32],
+            )
 
             assert hasattr(self, "_onedal_estimator")
             return self._onedal_estimator.predict_proba(X, queue=queue)
@@ -380,22 +349,14 @@ if daal_check_version((2024, "P", 1)):
             if queue is None or queue.sycl_device.is_cpu:
                 return daal4py_predict(self, X, "computeClassLogProbabilities")
 
-            if sklearn_check_version("1.0"):
-                X = validate_data(
-                    self,
-                    X,
-                    reset=False,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
-            else:
-                X = check_array(
-                    X,
-                    accept_sparse=_sparsity_enabled,
-                    accept_large_sparse=_sparsity_enabled,
-                    dtype=[np.float64, np.float32],
-                )
+            X = validate_data(
+                self,
+                X,
+                reset=False,
+                accept_sparse=_sparsity_enabled,
+                accept_large_sparse=_sparsity_enabled,
+                dtype=[np.float64, np.float32],
+            )
 
             assert hasattr(self, "_onedal_estimator")
             return self._onedal_estimator.predict_log_proba(X, queue=queue)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/ridge.py

@@ -35,18 +35,15 @@ if daal_check_version((2024, "P", 600)):
         from sklearn.utils import check_scalar
 
     from onedal.linear_model import Ridge as onedal_Ridge
-    from onedal.utils import _num_features, _num_samples
+    from onedal.utils.validation import _num_features, _num_samples
 
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchableEstimator, PatchingConditionsChain
-
-    if sklearn_check_version("1.6"):
-        from sklearn.utils.validation import validate_data
-    else:
-        validate_data = _sklearn_Ridge._validate_data
+    from .._utils import PatchingConditionsChain
+    from ..base import oneDALEstimator
+    from ..utils.validation import validate_data
 
     @control_n_jobs(decorated_methods=["fit", "predict", "score"])
-    class Ridge(PatchableEstimator, _sklearn_Ridge):
+    class Ridge(oneDALEstimator, _sklearn_Ridge):
         __doc__ = _sklearn_Ridge.__doc__
 
         if sklearn_check_version("1.2"):
@@ -307,15 +304,15 @@ if daal_check_version((2024, "P", 600)):
                         include_boundaries="left",
                     )
 
-            check_params = {
-                "X": X,
-                "y": y,
-                "dtype": [np.float64, np.float32],
-                "accept_sparse": ["csr", "csc", "coo"],
-                "y_numeric": True,
-                "multi_output": True,
-            }
-            X, y = validate_data(self, **check_params)
+            X, y = validate_data(
+                self,
+                X=X,
+                y=y,
+                dtype=[np.float64, np.float32],
+                accept_sparse=["csr", "csc", "coo"],
+                y_numeric=True,
+                multi_output=True,
+            )
 
             if not sklearn_check_version("1.2"):
                 self._normalize = _deprecate_normalize(
@@ -383,8 +380,8 @@ else:
     from daal4py.sklearn.linear_model import Ridge
     from onedal._device_offload import support_input_format
 
-    Ridge.fit = support_input_format(queue_param=False)(Ridge.fit)
-    Ridge.predict = support_input_format(queue_param=False)(Ridge.predict)
-    Ridge.score = support_input_format(queue_param=False)(Ridge.score)
+    Ridge.fit = support_input_format(Ridge.fit)
+    Ridge.predict = support_input_format(Ridge.predict)
+    Ridge.score = support_input_format(Ridge.score)
 
     logging.warning("Ridge requires oneDAL version >= 2024.6 but it was not found")

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/tests/test_linear.py

@@ -29,13 +29,71 @@ from onedal.tests.utils._dataframes_support import (
 from sklearnex.tests.utils import _IS_INTEL
 
 
+# Note: this is arranged as a fixture with a finalizer instead of as a parameter
+# 'True' / 'False' in order to undo the changes later so that it doesn't affect
+# other tests afterwards. It returns a function instead of making the change
+# directly, in order to avoid importing the estimator class before the import test
+# itself, but it still needs to import the class inside the the function that it
+# returns due to serialization logic in pytest causing differences w.r.t. current
+# closure where the function is called.
+@pytest.fixture(params=[False, True])
+def non_batched_route(request):
+    def change_parameters(queue, macro_block):
+        from sklearnex.linear_model import LinearRegression
+
+        if request.param and daal_check_version((2025, "P", 500)):
+            if queue and queue.sycl_device.is_gpu:
+                pytest.skip("Test for CPU-only functionality")
+            if macro_block is not None:
+                pytest.skip("Parameter combination with no effect")
+
+            non_batched_route.curr_cpu_max_cols_batched = (
+                LinearRegression.get_hyperparameters("fit").cpu_max_cols_batched
+            )
+            non_batched_route.curr_cpu_small_rows_threshold = (
+                LinearRegression.get_hyperparameters("fit").cpu_small_rows_threshold
+            )
+            non_batched_route.curr_cpu_small_rows_max_cols_batched = (
+                LinearRegression.get_hyperparameters(
+                    "fit"
+                ).cpu_small_rows_max_cols_batched
+            )
+            LinearRegression.get_hyperparameters("fit").cpu_max_cols_batched = 1
+            LinearRegression.get_hyperparameters("fit").cpu_small_rows_threshold = 1
+            LinearRegression.get_hyperparameters(
+                "fit"
+            ).cpu_small_rows_max_cols_batched = 1
+
+        elif request.param and not daal_check_version((2025, "P", 500)):
+            pytest.skip("Functionality introduced in later versions")
+
+    def restore_params():
+        from sklearnex.linear_model import LinearRegression
+
+        if request.param and daal_check_version((2025, "P", 500)):
+            LinearRegression.get_hyperparameters("fit").cpu_max_cols_batched = (
+                non_batched_route.curr_cpu_max_cols_batched
+            )
+            LinearRegression.get_hyperparameters("fit").cpu_small_rows_threshold = (
+                non_batched_route.curr_cpu_small_rows_threshold
+            )
+            LinearRegression.get_hyperparameters(
+                "fit"
+            ).cpu_small_rows_max_cols_batched = (
+                non_batched_route.curr_cpu_small_rows_max_cols_batched
+            )
+
+    request.addfinalizer(restore_params)
+    return change_parameters
+
+
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("macro_block", [None, 1024])
 @pytest.mark.parametrize("overdetermined", [False, True])
 @pytest.mark.parametrize("multi_output", [False, True])
 def test_sklearnex_import_linear(
-    dataframe, queue, dtype, macro_block, overdetermined, multi_output
+    dataframe, queue, dtype, macro_block, non_batched_route, overdetermined, multi_output
 ):
     if (not overdetermined or multi_output) and not daal_check_version((2025, "P", 1)):
         pytest.skip("Functionality introduced in later versions")
@@ -65,6 +123,7 @@ def test_sklearnex_import_linear(
         hparams = LinearRegression.get_hyperparameters("fit")
         hparams.cpu_macro_block = macro_block
         hparams.gpu_macro_block = macro_block
+    non_batched_route(queue, macro_block)
 
     X = X.astype(dtype=dtype)
     y = y.astype(dtype=dtype)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/tests/test_logreg.py

@@ -49,7 +49,7 @@ def test_sklearnex_multiclass_classification(dataframe, queue):
     from sklearnex.linear_model import LogisticRegression
 
     X, y = load_iris(return_X_y=True)
-    X_train, X_test, y_train, y_test = prepare_input(X, y, dataframe, queue)
+    X_train, X_test, y_train, y_test = prepare_input(X, y, dataframe, queue=queue)
 
     logreg = LogisticRegression(fit_intercept=True, solver="lbfgs", max_iter=200).fit(
         X_train, y_train
@@ -72,7 +72,7 @@ def test_sklearnex_binary_classification(dataframe, queue):
     from sklearnex.linear_model import LogisticRegression
 
     X, y = load_breast_cancer(return_X_y=True)
-    X_train, X_test, y_train, y_test = prepare_input(X, y, dataframe, queue)
+    X_train, X_test, y_train, y_test = prepare_input(X, y, dataframe, queue=queue)
 
     logreg = LogisticRegression(fit_intercept=True, solver="newton-cg", max_iter=100).fit(
         X_train, y_train

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/manifold/t_sne.py

@@ -14,13 +14,15 @@
 # limitations under the License.
 # ===============================================================================
 
-from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
 from daal4py.sklearn.manifold import TSNE
 from onedal._device_offload import support_input_format
 
-from .._utils import PatchableEstimator
+from ..base import oneDALEstimator
 
-TSNE.fit = support_input_format(queue_param=False)(TSNE.fit)
-TSNE.fit_transform = support_input_format(queue_param=False)(TSNE.fit_transform)
-TSNE._doc_link_module = "daal4py"
-TSNE._doc_link_template = PatchableEstimator._doc_link_template
+TSNE.fit = support_input_format(TSNE.fit)
+TSNE.fit_transform = support_input_format(TSNE.fit_transform)
+
+if sklearn_check_version("1.4"):
+    TSNE._doc_link_module = "daal4py"
+    TSNE._doc_link_url_param_generator = oneDALEstimator._doc_link_url_param_generator

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/metrics/pairwise.py

@@ -17,6 +17,4 @@
 from daal4py.sklearn.metrics import pairwise_distances
 from onedal._device_offload import support_input_format
 
-pairwise_distances = support_input_format(freefunc=True, queue_param=False)(
-    pairwise_distances
-)
+pairwise_distances = support_input_format(pairwise_distances)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/metrics/ranking.py

@@ -17,4 +17,4 @@
 from daal4py.sklearn.metrics import roc_auc_score
 from onedal._device_offload import support_input_format
 
-roc_auc_score = support_input_format(freefunc=True, queue_param=False)(roc_auc_score)
+roc_auc_score = support_input_format(roc_auc_score)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/model_selection/split.py

@@ -17,6 +17,4 @@
 from daal4py.sklearn.model_selection import train_test_split
 from onedal._device_offload import support_input_format
 
-train_test_split = support_input_format(freefunc=True, queue_param=False)(
-    train_test_split
-)
+train_test_split = support_input_format(train_test_split)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/neighbors/_lof.py

@@ -15,6 +15,7 @@
 # ===============================================================================
 
 import warnings
+from functools import wraps
 
 import numpy as np
 from sklearn.neighbors import LocalOutlierFactor as _sklearn_LocalOutlierFactor
@@ -28,11 +29,7 @@ from sklearnex.neighbors.common import KNeighborsDispatchingBase
 from sklearnex.neighbors.knn_unsupervised import NearestNeighbors
 
 from ..utils._array_api import get_namespace
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_LocalOutlierFactor._validate_data
+from ..utils.validation import check_feature_names
 
 
 @control_n_jobs(decorated_methods=["fit", "kneighbors", "_kneighbors"])
@@ -59,7 +56,7 @@ class LocalOutlierFactor(KNeighborsDispatchingBase, _sklearn_LocalOutlierFactor)
         if sklearn_check_version("1.2"):
             self._validate_params()
 
-        self._onedal_knn_fit(X, y, queue)
+        self._onedal_knn_fit(X, y, queue=queue)
 
         if self.contamination != "auto":
             if not (0.0 < self.contamination <= 0.5):
@@ -146,34 +143,15 @@ class LocalOutlierFactor(KNeighborsDispatchingBase, _sklearn_LocalOutlierFactor)
     # This would cause issues in fit_predict. Also, available_if
     # is hard to unwrap, and this is the most straighforward way.
     @available_if(_sklearn_LocalOutlierFactor._check_novelty_fit_predict)
+    @wraps(_sklearn_LocalOutlierFactor.fit_predict, assigned=["__doc__"])
     @wrap_output_data
     def fit_predict(self, X, y=None):
-        """Fit the model to the training set X and return the labels.
-
-        **Not available for novelty detection (when novelty is set to True).**
-        Label is 1 for an inlier and -1 for an outlier according to the LOF
-        score and the contamination parameter.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features), default=None
-            The query sample or samples to compute the Local Outlier Factor
-            w.r.t. the training samples.
-
-        y : Ignored
-            Not used, present for API consistency by convention.
-
-        Returns
-        -------
-        is_inlier : ndarray of shape (n_samples,)
-            Returns -1 for anomalies/outliers and 1 for inliers.
-        """
         return self.fit(X)._predict()
 
     def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         check_is_fitted(self)
-        if sklearn_check_version("1.0") and X is not None:
-            self._check_feature_names(X, reset=False)
+        if X is not None:
+            check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "kneighbors",
@@ -189,34 +167,9 @@ class LocalOutlierFactor(KNeighborsDispatchingBase, _sklearn_LocalOutlierFactor)
     kneighbors = wrap_output_data(_kneighbors)
 
     @available_if(_sklearn_LocalOutlierFactor._check_novelty_score_samples)
+    @wraps(_sklearn_LocalOutlierFactor.score_samples, assigned=["__doc__"])
     @wrap_output_data
     def score_samples(self, X):
-        """Opposite of the Local Outlier Factor of X.
-
-        It is the opposite as bigger is better, i.e. large values correspond
-        to inliers.
-
-        **Only available for novelty detection (when novelty is set to True).**
-        The argument X is supposed to contain *new data*: if X contains a
-        point from training, it considers the later in its own neighborhood.
-        Also, the samples in X are not considered in the neighborhood of any
-        point. Because of this, the scores obtained via ``score_samples`` may
-        differ from the standard LOF scores.
-        The standard LOF scores for the training data is available via the
-        ``negative_outlier_factor_`` attribute.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            The query sample or samples to compute the Local Outlier Factor
-            w.r.t. the training samples.
-
-        Returns
-        -------
-        opposite_lof_scores : ndarray of shape (n_samples,)
-            The opposite of the Local Outlier Factor of each input samples.
-            The lower, the more abnormal.
-        """
         check_is_fitted(self)
 
         distances_X, neighbors_indices_X = self._kneighbors(