scikit-learn-intelex 2025.10.0__py313-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/model_selection/split.py

@@ -0,0 +1,20 @@
+# ===============================================================================
+# Copyright 2021 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 daal4py.sklearn.model_selection import train_test_split
+from onedal._device_offload import support_input_format
+
+train_test_split = support_input_format(train_test_split)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/model_selection/tests/test_model_selection.py

@@ -0,0 +1,34 @@
+# ===============================================================================
+# Copyright 2021 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.
+# ===============================================================================
+
+import numpy as np
+from numpy.testing import assert_allclose
+
+
+# TODO:
+# add pytest params for checking different dataframe inputs/outputs.
+def test_sklearnex_import_train_test_split():
+    from sklearnex.model_selection import train_test_split
+
+    X = np.arange(100).reshape((10, 10))
+    y = np.arange(10)
+
+    split = train_test_split(X, y, test_size=None, train_size=0.5)
+    X_train, X_test, y_train, y_test = split
+    assert len(y_test) == len(y_train)
+
+    assert_allclose(X_train[:, 0], y_train * 10)
+    assert_allclose(X_test[:, 0], y_test * 10)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/neighbors/__init__.py

@@ -0,0 +1,27 @@
+# ===============================================================================
+# Copyright 2021 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 ._lof import LocalOutlierFactor
+from .knn_classification import KNeighborsClassifier
+from .knn_regression import KNeighborsRegressor
+from .knn_unsupervised import NearestNeighbors
+
+__all__ = [
+    "KNeighborsClassifier",
+    "KNeighborsRegressor",
+    "LocalOutlierFactor",
+    "NearestNeighbors",
+]

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/neighbors/_lof.py

@@ -0,0 +1,189 @@
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+import warnings
+from functools import wraps
+
+import numpy as np
+from sklearn.neighbors import LocalOutlierFactor as _sklearn_LocalOutlierFactor
+from sklearn.utils.metaestimators import available_if
+from sklearn.utils.validation import check_is_fitted
+
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
+from sklearnex._device_offload import dispatch, wrap_output_data
+from sklearnex.neighbors.common import KNeighborsDispatchingBase
+from sklearnex.neighbors.knn_unsupervised import NearestNeighbors
+
+from ..utils._array_api import get_namespace
+from ..utils.validation import check_feature_names
+
+
+@control_n_jobs(decorated_methods=["fit", "kneighbors", "_kneighbors"])
+class LocalOutlierFactor(KNeighborsDispatchingBase, _sklearn_LocalOutlierFactor):
+    __doc__ = (
+        _sklearn_LocalOutlierFactor.__doc__
+        + "\n NOTE: When X=None, methods kneighbors, kneighbors_graph, and predict will"
+        + "\n only output numpy arrays. In that case, the only way to offload to gpu"
+        + "\n is to use a global queue (e.g. using config_context)"
+    )
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {
+            **_sklearn_LocalOutlierFactor._parameter_constraints
+        }
+
+    # Only certain methods should be taken from knn to prevent code
+    # duplication. Inheriting would yield a complicated inheritance
+    # structure and violate the sklearn inheritance path.
+    _save_attributes = NearestNeighbors._save_attributes
+    _onedal_knn_fit = NearestNeighbors._onedal_fit
+    _onedal_kneighbors = NearestNeighbors._onedal_kneighbors
+
+    def _onedal_fit(self, X, y, queue=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+
+        self._onedal_knn_fit(X, y, queue=queue)
+
+        if self.contamination != "auto":
+            if not (0.0 < self.contamination <= 0.5):
+                raise ValueError(
+                    "contamination must be in (0, 0.5], " "got: %f" % self.contamination
+                )
+
+        n_samples = self.n_samples_fit_
+
+        if self.n_neighbors > n_samples:
+            warnings.warn(
+                "n_neighbors (%s) is greater than the "
+                "total number of samples (%s). n_neighbors "
+                "will be set to (n_samples - 1) for estimation."
+                % (self.n_neighbors, n_samples)
+            )
+        self.n_neighbors_ = max(1, min(self.n_neighbors, n_samples - 1))
+
+        (
+            self._distances_fit_X_,
+            _neighbors_indices_fit_X_,
+        ) = self._onedal_kneighbors(n_neighbors=self.n_neighbors_, queue=queue)
+
+        # Sklearn includes a check for float32 at this point which may not be
+        # necessary for onedal
+
+        self._lrd = self._local_reachability_density(
+            self._distances_fit_X_, _neighbors_indices_fit_X_
+        )
+
+        # Compute lof score over training samples to define offset_:
+        lrd_ratios_array = self._lrd[_neighbors_indices_fit_X_] / self._lrd[:, np.newaxis]
+
+        self.negative_outlier_factor_ = -np.mean(lrd_ratios_array, axis=1)
+
+        if self.contamination == "auto":
+            # inliers score around -1 (the higher, the less abnormal).
+            self.offset_ = -1.5
+        else:
+            self.offset_ = np.percentile(
+                self.negative_outlier_factor_, 100.0 * self.contamination
+            )
+
+        # adoption of warning for data with duplicated samples from
+        # https://github.com/scikit-learn/scikit-learn/pull/28773
+        if sklearn_check_version("1.6"):
+            if np.min(self.negative_outlier_factor_) < -1e7 and not self.novelty:
+                warnings.warn(
+                    "Duplicate values are leading to incorrect results. "
+                    "Increase the number of neighbors for more accurate results."
+                )
+
+        return self
+
+    def fit(self, X, y=None):
+        result = dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": _sklearn_LocalOutlierFactor.fit,
+            },
+            X,
+            None,
+        )
+        return result
+
+    def _predict(self, X=None):
+        check_is_fitted(self)
+
+        if X is not None:
+            xp, _ = get_namespace(X)
+            output = self.decision_function(X) < 0
+            is_inlier = xp.ones_like(output, dtype=int)
+            is_inlier[output] = -1
+        else:
+            is_inlier = np.ones(self.n_samples_fit_, dtype=int)
+            is_inlier[self.negative_outlier_factor_ < self.offset_] = -1
+
+        return is_inlier
+
+    # This had to be done because predict loses the queue when no
+    # argument is given and it is a dpctl tensor or dpnp array.
+    # This would cause issues in fit_predict. Also, available_if
+    # is hard to unwrap, and this is the most straightforward 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):
+        return self.fit(X)._predict()
+
+    def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
+        check_is_fitted(self)
+        if X is not None:
+            check_feature_names(self, X, reset=False)
+        return dispatch(
+            self,
+            "kneighbors",
+            {
+                "onedal": self.__class__._onedal_kneighbors,
+                "sklearn": _sklearn_LocalOutlierFactor.kneighbors,
+            },
+            X,
+            n_neighbors=n_neighbors,
+            return_distance=return_distance,
+        )
+
+    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):
+        check_is_fitted(self)
+
+        distances_X, neighbors_indices_X = self._kneighbors(
+            X, n_neighbors=self.n_neighbors_
+        )
+
+        X_lrd = self._local_reachability_density(
+            distances_X,
+            neighbors_indices_X,
+        )
+
+        lrd_ratios_array = self._lrd[neighbors_indices_X] / X_lrd[:, np.newaxis]
+
+        return -np.mean(lrd_ratios_array, axis=1)
+
+    fit.__doc__ = _sklearn_LocalOutlierFactor.fit.__doc__
+    kneighbors.__doc__ = _sklearn_LocalOutlierFactor.kneighbors.__doc__

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/neighbors/common.py

@@ -0,0 +1,313 @@
+# ==============================================================================
+# Copyright 2023 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.
+# ==============================================================================
+
+import warnings
+
+import numpy as np
+from scipy import sparse as sp
+from sklearn.neighbors._ball_tree import BallTree
+from sklearn.neighbors._base import VALID_METRICS, KNeighborsMixin
+from sklearn.neighbors._base import NeighborsBase as _sklearn_NeighborsBase
+from sklearn.neighbors._kd_tree import KDTree
+from sklearn.utils.validation import check_is_fitted
+
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal._device_offload import _transfer_to_host
+from onedal.utils.validation import _check_array, _num_features, _num_samples
+
+from .._utils import PatchingConditionsChain
+from ..base import oneDALEstimator
+from ..utils._array_api import get_namespace
+from ..utils.validation import check_feature_names
+
+
+class KNeighborsDispatchingBase(oneDALEstimator):
+    def _fit_validation(self, X, y=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+        check_feature_names(self, X, reset=True)
+        if self.metric_params is not None and "p" in self.metric_params:
+            if self.p is not None:
+                warnings.warn(
+                    "Parameter p is found in metric_params. "
+                    "The corresponding parameter from __init__ "
+                    "is ignored.",
+                    SyntaxWarning,
+                    stacklevel=2,
+                )
+            self.effective_metric_params_ = self.metric_params.copy()
+            effective_p = self.metric_params["p"]
+        else:
+            self.effective_metric_params_ = {}
+            effective_p = self.p
+
+        self.effective_metric_params_["p"] = effective_p
+        self.effective_metric_ = self.metric
+        # For minkowski distance, use more efficient methods where available
+        if self.metric == "minkowski":
+            p = self.effective_metric_params_["p"]
+            if p == 1:
+                self.effective_metric_ = "manhattan"
+            elif p == 2:
+                self.effective_metric_ = "euclidean"
+            elif p == np.inf:
+                self.effective_metric_ = "chebyshev"
+
+        if not isinstance(X, (KDTree, BallTree, _sklearn_NeighborsBase)):
+            self._fit_X = _check_array(
+                X, dtype=[np.float64, np.float32], accept_sparse=True
+            )
+            self.n_samples_fit_ = _num_samples(self._fit_X)
+            self.n_features_in_ = _num_features(self._fit_X)
+
+            if self.algorithm == "auto":
+                # A tree approach is better for small number of neighbors or small
+                # number of features, with KDTree generally faster when available
+                is_n_neighbors_valid_for_brute = (
+                    self.n_neighbors is not None
+                    and self.n_neighbors >= self._fit_X.shape[0] // 2
+                )
+                if self._fit_X.shape[1] > 15 or is_n_neighbors_valid_for_brute:
+                    self._fit_method = "brute"
+                else:
+                    if self.effective_metric_ in VALID_METRICS["kd_tree"]:
+                        self._fit_method = "kd_tree"
+                    elif (
+                        callable(self.effective_metric_)
+                        or self.effective_metric_ in VALID_METRICS["ball_tree"]
+                    ):
+                        self._fit_method = "ball_tree"
+                    else:
+                        self._fit_method = "brute"
+            else:
+                self._fit_method = self.algorithm
+
+        if hasattr(self, "_onedal_estimator"):
+            delattr(self, "_onedal_estimator")
+        # To cover test case when we pass patched
+        # estimator as an input for other estimator
+        if isinstance(X, _sklearn_NeighborsBase):
+            self._fit_X = X._fit_X
+            self._tree = X._tree
+            self._fit_method = X._fit_method
+            self.n_samples_fit_ = X.n_samples_fit_
+            self.n_features_in_ = X.n_features_in_
+            if hasattr(X, "_onedal_estimator"):
+                self.effective_metric_params_.pop("p")
+                if self._fit_method == "ball_tree":
+                    X._tree = BallTree(
+                        X._fit_X,
+                        self.leaf_size,
+                        metric=self.effective_metric_,
+                        **self.effective_metric_params_,
+                    )
+                elif self._fit_method == "kd_tree":
+                    X._tree = KDTree(
+                        X._fit_X,
+                        self.leaf_size,
+                        metric=self.effective_metric_,
+                        **self.effective_metric_params_,
+                    )
+                elif self._fit_method == "brute":
+                    X._tree = None
+                else:
+                    raise ValueError("algorithm = '%s' not recognized" % self.algorithm)
+
+        elif isinstance(X, BallTree):
+            self._fit_X = X.data
+            self._tree = X
+            self._fit_method = "ball_tree"
+            self.n_samples_fit_ = X.data.shape[0]
+            self.n_features_in_ = X.data.shape[1]
+
+        elif isinstance(X, KDTree):
+            self._fit_X = X.data
+            self._tree = X
+            self._fit_method = "kd_tree"
+            self.n_samples_fit_ = X.data.shape[0]
+            self.n_features_in_ = X.data.shape[1]
+
+    def _onedal_supported(self, device, method_name, *data):
+        if method_name == "fit":
+            self._fit_validation(data[0], data[1])
+
+        class_name = self.__class__.__name__
+        is_classifier = "Classifier" in class_name
+        is_regressor = "Regressor" in class_name
+        is_unsupervised = not (is_classifier or is_regressor)
+        patching_status = PatchingConditionsChain(
+            f"sklearn.neighbors.{class_name}.{method_name}"
+        )
+        if not patching_status.and_condition(
+            "radius" not in method_name, "RadiusNeighbors not implemented in sklearnex"
+        ):
+            return patching_status
+
+        if not patching_status.and_condition(
+            not isinstance(data[0], (KDTree, BallTree, _sklearn_NeighborsBase)),
+            f"Input type {type(data[0])} is not supported.",
+        ):
+            return patching_status
+
+        if self._fit_method in ["auto", "ball_tree"]:
+            condition = (
+                self.n_neighbors is not None
+                and self.n_neighbors >= self.n_samples_fit_ // 2
+            )
+            if self.n_features_in_ > 15 or condition:
+                result_method = "brute"
+            else:
+                if self.effective_metric_ in ["euclidean"]:
+                    result_method = "kd_tree"
+                else:
+                    result_method = "brute"
+        else:
+            result_method = self._fit_method
+
+        p_less_than_one = (
+            "p" in self.effective_metric_params_.keys()
+            and self.effective_metric_params_["p"] < 1
+        )
+        if not patching_status.and_condition(
+            not p_less_than_one, '"p" metric parameter is less than 1'
+        ):
+            return patching_status
+
+        if not patching_status.and_condition(
+            not sp.issparse(data[0]), "Sparse input is not supported."
+        ):
+            return patching_status
+
+        if not is_unsupervised:
+            is_valid_weights = self.weights in ["uniform", "distance"]
+            if is_classifier:
+                class_count = 1
+            is_single_output = False
+            y = None
+            # To check multioutput, might be overhead
+            if len(data) > 1:
+                y = np.asarray(data[1])
+                if is_classifier:
+                    class_count = len(np.unique(y))
+            if hasattr(self, "_onedal_estimator"):
+                y = self._onedal_estimator._y
+            if y is not None and hasattr(y, "ndim") and hasattr(y, "shape"):
+                is_single_output = y.ndim == 1 or y.ndim == 2 and y.shape[1] == 1
+
+        # TODO: add native support for these metric names
+        metrics_map = {"manhattan": ["l1", "cityblock"], "euclidean": ["l2"]}
+        for origin, aliases in metrics_map.items():
+            if self.effective_metric_ in aliases:
+                self.effective_metric_ = origin
+                break
+        if self.effective_metric_ == "manhattan":
+            self.effective_metric_params_["p"] = 1
+        elif self.effective_metric_ == "euclidean":
+            self.effective_metric_params_["p"] = 2
+
+        onedal_brute_metrics = [
+            "manhattan",
+            "minkowski",
+            "euclidean",
+            "chebyshev",
+            "cosine",
+        ]
+        onedal_kdtree_metrics = ["euclidean"]
+        is_valid_for_brute = (
+            result_method == "brute" and self.effective_metric_ in onedal_brute_metrics
+        )
+        is_valid_for_kd_tree = (
+            result_method == "kd_tree" and self.effective_metric_ in onedal_kdtree_metrics
+        )
+        if result_method == "kd_tree":
+            if not patching_status.and_condition(
+                device != "gpu", '"kd_tree" method is not supported on GPU.'
+            ):
+                return patching_status
+
+        if not patching_status.and_condition(
+            is_valid_for_kd_tree or is_valid_for_brute,
+            f"{result_method} with {self.effective_metric_} metric is not supported.",
+        ):
+            return patching_status
+        if not is_unsupervised:
+            if not patching_status.and_conditions(
+                [
+                    (is_single_output, "Only single output is supported."),
+                    (
+                        is_valid_weights,
+                        f'"{type(self.weights)}" weights type is not supported.',
+                    ),
+                ]
+            ):
+                return patching_status
+        if method_name == "fit":
+            if is_classifier:
+                patching_status.and_condition(
+                    class_count >= 2, "One-class case is not supported."
+                )
+            return patching_status
+        if method_name in ["predict", "predict_proba", "kneighbors", "score"]:
+            patching_status.and_condition(
+                hasattr(self, "_onedal_estimator"), "oneDAL model was not trained."
+            )
+            return patching_status
+        raise RuntimeError(f"Unknown method {method_name} in {class_name}")
+
+    def _onedal_gpu_supported(self, method_name, *data):
+        return self._onedal_supported("gpu", method_name, *data)
+
+    def _onedal_cpu_supported(self, method_name, *data):
+        return self._onedal_supported("cpu", method_name, *data)
+
+    def kneighbors_graph(self, X=None, n_neighbors=None, mode="connectivity"):
+        check_is_fitted(self)
+        if n_neighbors is None:
+            n_neighbors = self.n_neighbors
+
+        # check the input only in self.kneighbors
+
+        # construct CSR matrix representation of the k-NN graph
+        # requires moving data to host to construct the csr_matrix
+        if mode == "connectivity":
+            A_ind = self.kneighbors(X, n_neighbors, return_distance=False)
+            _, (A_ind,) = _transfer_to_host(A_ind)
+            n_queries = A_ind.shape[0]
+            A_data = np.ones(n_queries * n_neighbors)
+
+        elif mode == "distance":
+            A_data, A_ind = self.kneighbors(X, n_neighbors, return_distance=True)
+            _, (A_data, A_ind) = _transfer_to_host(A_data, A_ind)
+            A_data = np.reshape(A_data, (-1,))
+
+        else:
+            raise ValueError(
+                'Unsupported mode, must be one of "connectivity", '
+                f'or "distance" but got "{mode}" instead'
+            )
+
+        n_queries = A_ind.shape[0]
+        n_samples_fit = self.n_samples_fit_
+        n_nonzero = n_queries * n_neighbors
+        A_indptr = np.arange(0, n_nonzero + 1, n_neighbors)
+
+        kneighbors_graph = sp.csr_matrix(
+            (A_data, np.reshape(A_ind, (-1,)), A_indptr), shape=(n_queries, n_samples_fit)
+        )
+
+        return kneighbors_graph
+
+    kneighbors_graph.__doc__ = KNeighborsMixin.kneighbors_graph.__doc__