scikit-learn-intelex 2024.0.1__py312-none-win_amd64.whl

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/neighbors/tests/test_neighbors.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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
+import pytest
+from numpy.testing import assert_allclose
+
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_knn_classifier(dataframe, queue):
+    from sklearnex.neighbors import KNeighborsClassifier
+
+    X = _convert_to_dataframe([[0], [1], [2], [3]], sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe([0, 0, 1, 1], sycl_queue=queue, target_df=dataframe)
+    neigh = KNeighborsClassifier(n_neighbors=3).fit(X, y)
+    y_test = _convert_to_dataframe([[1.1]], sycl_queue=queue, target_df=dataframe)
+    pred = _as_numpy(neigh.predict(y_test))
+    assert "sklearnex" in neigh.__module__
+    assert_allclose(pred, [0])
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_knn_regression(dataframe, queue):
+    from sklearnex.neighbors import KNeighborsRegressor
+
+    X = _convert_to_dataframe([[0], [1], [2], [3]], sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe([0, 0, 1, 1], sycl_queue=queue, target_df=dataframe)
+    neigh = KNeighborsRegressor(n_neighbors=2).fit(X, y)
+    y_test = _convert_to_dataframe([[1.5]], sycl_queue=queue, target_df=dataframe)
+    pred = _as_numpy(neigh.predict(y_test))
+    assert "sklearnex" in neigh.__module__
+    assert_allclose(pred, [0.5])
+
+
+# TODO:
+# investigate failure for `dpnp.ndarrays` and `dpctl.tensors`.
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(dataframe_filter_="numpy")
+)
+def test_sklearnex_import_nn(dataframe, queue):
+    from sklearnex.neighbors import NearestNeighbors
+
+    X = [[0, 0, 2], [1, 0, 0], [0, 0, 1]]
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    test = _convert_to_dataframe([[0, 0, 1.3]], sycl_queue=queue, target_df=dataframe)
+    neigh = NearestNeighbors(n_neighbors=2).fit(X)
+    result = neigh.kneighbors(test, 2, return_distance=False)
+    result = _as_numpy(result)
+    assert "sklearnex" in neigh.__module__
+    assert_allclose(result, [[2, 0]])
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_lof(dataframe, queue):
+    from sklearnex.neighbors import LocalOutlierFactor
+
+    X = [[7, 7, 7], [1, 0, 0], [0, 0, 1], [0, 0, 1]]
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    lof = LocalOutlierFactor(n_neighbors=2)
+    result = lof.fit_predict(X)
+    result = _as_numpy(result)
+    assert hasattr(lof, "_knn")
+    assert "sklearnex" in lof.__module__
+    assert "sklearnex" in lof._knn.__module__
+    assert_allclose(result, [-1, 1, 1, 1])

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview/__init__.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+__all__ = ["cluster", "decomposition"]

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview/cluster/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from .k_means import KMeans
+
+__all__ = ["KMeans"]

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview/cluster/_common.py

@@ -0,0 +1,84 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from abc import ABC
+
+
+def get_cluster_centers(self):
+    return self._cluster_centers_
+
+
+def set_cluster_centers(self, value):
+    self._cluster_centers_ = value
+    if hasattr(self, "_onedal_estimator"):
+        self._onedal_estimator.cluster_centers_ = value
+
+
+def get_labels(self):
+    return self._labels_
+
+
+def set_labels(self, value):
+    self._labels_ = value
+    if hasattr(self, "_onedal_estimator"):
+        self._onedal_estimator.labels_ = value
+
+
+def get_inertia(self):
+    return self._inertia_
+
+
+def set_inertia(self, value):
+    self._inertia_ = value
+    if hasattr(self, "_onedal_estimator"):
+        self._onedal_estimator.inertia_ = value
+
+
+def get_n_iter(self):
+    return self._n_iter_
+
+
+def set_n_iter(self, value):
+    self._n_iter_ = value
+    if hasattr(self, "_onedal_estimator"):
+        self._onedal_estimator.n_iter_ = value
+
+
+class BaseKMeans(ABC):
+    def _save_attributes(self):
+        assert hasattr(self, "_onedal_estimator")
+        self.n_features_in_ = self._onedal_estimator.n_features_in_
+        self.fit_status_ = 0
+        self._tol = self._onedal_estimator._tol
+        self._n_init = self._onedal_estimator._n_init
+        self._n_iter_ = self._onedal_estimator.n_iter_
+        self._labels_ = self._onedal_estimator.labels_
+        self._inertia_ = self._onedal_estimator.inertia_
+        self._algorithm = self._onedal_estimator.algorithm
+        self._cluster_centers_ = self._onedal_estimator.cluster_centers_
+        self._sparse = False
+
+        self.n_iter_ = property(get_n_iter, set_n_iter)
+        self.labels_ = property(get_labels, set_labels)
+        self.inertia_ = property(get_labels, set_inertia)
+        self.cluster_centers_ = property(get_cluster_centers, set_cluster_centers)
+
+        self._is_in_fit = True
+        self.n_iter_ = self._n_iter_
+        self.labels_ = self._labels_
+        self.inertia_ = self._inertia_
+        self.cluster_centers_ = self._cluster_centers_
+        self._is_in_fit = False

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview/cluster/k_means.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python
+# ==============================================================================
+# 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 logging
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+    import numpy as np
+    from scipy.sparse import issparse
+    from sklearn.cluster import KMeans as sklearn_KMeans
+    from sklearn.utils._openmp_helpers import _openmp_effective_n_threads
+    from sklearn.utils.validation import (
+        _deprecate_positional_args,
+        _num_samples,
+        check_is_fitted,
+    )
+
+    from daal4py.sklearn._utils import sklearn_check_version
+    from onedal.cluster import KMeans as onedal_KMeans
+
+    from ..._device_offload import dispatch, wrap_output_data
+    from ..._utils import PatchingConditionsChain
+    from ._common import BaseKMeans
+
+    class KMeans(sklearn_KMeans, BaseKMeans):
+        __doc__ = sklearn_KMeans.__doc__
+        n_iter_, inertia_ = None, None
+        labels_, cluster_centers_ = None, None
+
+        if sklearn_check_version("1.2"):
+            _parameter_constraints: dict = {**sklearn_KMeans._parameter_constraints}
+
+            @_deprecate_positional_args
+            def __init__(
+                self,
+                n_clusters=8,
+                *,
+                init="k-means++",
+                n_init="auto" if sklearn_check_version("1.4") else "warn",
+                max_iter=300,
+                tol=1e-4,
+                verbose=0,
+                random_state=None,
+                copy_x=True,
+                algorithm="lloyd",
+            ):
+                super().__init__(
+                    n_clusters=n_clusters,
+                    init=init,
+                    max_iter=max_iter,
+                    tol=tol,
+                    n_init=n_init,
+                    verbose=verbose,
+                    random_state=random_state,
+                    copy_x=copy_x,
+                    algorithm=algorithm,
+                )
+
+        elif sklearn_check_version("1.0"):
+
+            @_deprecate_positional_args
+            def __init__(
+                self,
+                n_clusters=8,
+                *,
+                init="k-means++",
+                n_init=10,
+                max_iter=300,
+                tol=1e-4,
+                verbose=0,
+                random_state=None,
+                copy_x=True,
+                algorithm="auto",
+            ):
+                super().__init__(
+                    n_clusters=n_clusters,
+                    init=init,
+                    max_iter=max_iter,
+                    tol=tol,
+                    n_init=n_init,
+                    verbose=verbose,
+                    random_state=random_state,
+                    copy_x=copy_x,
+                    algorithm=algorithm,
+                )
+
+        else:
+
+            @_deprecate_positional_args
+            def __init__(
+                self,
+                n_clusters=8,
+                *,
+                init="k-means++",
+                n_init=10,
+                max_iter=300,
+                tol=1e-4,
+                precompute_distances="deprecated",
+                verbose=0,
+                random_state=None,
+                copy_x=True,
+                n_jobs="deprecated",
+                algorithm="auto",
+            ):
+                super().__init__(
+                    n_clusters=n_clusters,
+                    init=init,
+                    max_iter=max_iter,
+                    tol=tol,
+                    precompute_distances=precompute_distances,
+                    n_init=n_init,
+                    verbose=verbose,
+                    random_state=random_state,
+                    copy_x=copy_x,
+                    n_jobs=n_jobs,
+                    algorithm=algorithm,
+                )
+
+        def _initialize_onedal_estimator(self):
+            onedal_params = {
+                "n_clusters": self.n_clusters,
+                "init": self.init,
+                "max_iter": self.max_iter,
+                "tol": self.tol,
+                "n_init": self.n_init,
+                "verbose": self.verbose,
+                "random_state": self.random_state,
+            }
+
+            self._onedal_estimator = onedal_KMeans(**onedal_params)
+
+        def _onedal_fit_supported(self, method_name, X, y=None, sample_weight=None):
+            assert method_name == "fit"
+
+            class_name = self.__class__.__name__
+            patching_status = PatchingConditionsChain(f"sklearn.cluster.{class_name}.fit")
+
+            sample_count = _num_samples(X)
+            self._algorithm = self.algorithm
+            supported_algs = ["auto", "full", "lloyd"]
+            correct_count = self.n_clusters < sample_count
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only lloyd algorithm is supported.",
+                    ),
+                    (not issparse(self.init), "Sparse init values are not supported"),
+                    (correct_count, "n_clusters is smaller than number of samples"),
+                    (sample_weight is None, "Sample weight is not None."),
+                    (not issparse(X), "Sparse input is not supported."),
+                ]
+            )
+
+            return patching_status
+
+        def fit(self, X, y=None, sample_weight=None):
+            """Compute k-means clustering.
+
+            Parameters
+            ----------
+            X : array-like or sparse matrix, shape=(n_samples, n_features)
+                Training instances to cluster. It must be noted that the data
+                will be converted to C ordering, which will cause a memory
+                copy if the given data is not C-contiguous.
+
+            y : Ignored
+                not used, present here for API consistency by convention.
+
+            sample_weight : array-like, shape (n_samples,), optional
+                The weights for each observation in X. If None, all observations
+                are assigned equal weight (default: None)
+
+            """
+
+            if sklearn_check_version("1.0"):
+                self._check_feature_names(X, reset=True)
+            if sklearn_check_version("1.2"):
+                self._validate_params()
+
+            dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": sklearn_KMeans.fit,
+                },
+                X,
+                y,
+                sample_weight,
+            )
+
+            return self
+
+        def _onedal_fit(self, X, _, sample_weight, queue=None):
+            assert sample_weight is None
+
+            X = self._validate_data(
+                X,
+                accept_sparse=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if sklearn_check_version("1.2"):
+                self._check_params_vs_input(X)
+            else:
+                self._check_params(X)
+
+            self._n_features_out = self.n_clusters
+            self._n_threads = _openmp_effective_n_threads()
+
+            self._initialize_onedal_estimator()
+            self._onedal_estimator.fit(X, queue=queue)
+
+            self._save_attributes()
+
+        def _onedal_predict_supported(self, method_name, X):
+            assert method_name == "predict"
+
+            class_name = self.__class__.__name__
+            patching_status = PatchingConditionsChain(
+                f"sklearn.cluster.{class_name}.predict"
+            )
+
+            supported_algs = ["auto", "full", "lloyd"]
+            dense_centers = not issparse(self.cluster_centers_)
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only lloyd algorithm is supported.",
+                    ),
+                    (dense_centers, "Sparse clusters is not supported."),
+                    (not issparse(X), "Sparse input is not supported."),
+                ]
+            )
+
+            return patching_status
+
+        @wrap_output_data
+        def predict(self, X):
+            """Compute k-means clustering.
+
+            Parameters
+            ----------
+            X : array-like or sparse matrix, shape=(n_samples, n_features)
+                Training instances to cluster. It must be noted that the data
+                will be converted to C ordering, which will cause a memory
+                copy if the given data is not C-contiguous.
+
+            y : Ignored
+                not used, present here for API consistency by convention.
+
+            sample_weight : array-like, shape (n_samples,), optional
+                The weights for each observation in X. If None, all observations
+                are assigned equal weight (default: None)
+
+            """
+
+            if sklearn_check_version("1.0"):
+                self._check_feature_names(X, reset=True)
+            if sklearn_check_version("1.2"):
+                self._validate_params()
+
+            return dispatch(
+                self,
+                "predict",
+                {
+                    "onedal": self.__class__._onedal_predict,
+                    "sklearn": sklearn_KMeans.predict,
+                },
+                X,
+            )
+
+        def _onedal_predict(self, X, queue=None):
+            X = self._validate_data(
+                X, accept_sparse=False, reset=False, dtype=[np.float64, np.float32]
+            )
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.predict(X, queue=queue)
+
+        def _onedal_supported(self, method_name, *data):
+            if method_name == "fit":
+                return self._onedal_fit_supported(method_name, *data)
+            if method_name == "predict":
+                return self._onedal_predict_supported(method_name, *data)
+            raise RuntimeError(
+                f"Unknown method {method_name} in {self.__class__.__name__}"
+            )
+
+        def _onedal_gpu_supported(self, method_name, *data):
+            return self._onedal_supported(method_name, *data)
+
+        def _onedal_cpu_supported(self, method_name, *data):
+            return self._onedal_supported(method_name, *data)
+
+        @wrap_output_data
+        def fit_transform(self, X, y=None, sample_weight=None):
+            """Compute clustering and transform X to cluster-distance space.
+
+            Equivalent to fit(X).transform(X), but more efficiently implemented.
+
+            Parameters
+            ----------
+            X : {array-like, sparse matrix} of shape (n_samples, n_features)
+                New data to transform.
+
+            y : Ignored
+                Not used, present here for API consistency by convention.
+
+            sample_weight : array-like of shape (n_samples,), default=None
+                The weights for each observation in X. If None, all observations
+                are assigned equal weight.
+
+            Returns
+            -------
+            X_new : ndarray of shape (n_samples, n_clusters)
+                X transformed in the new space.
+            """
+            return self.fit(X, sample_weight=sample_weight)._transform(X)
+
+        @wrap_output_data
+        def transform(self, X):
+            """Transform X to a cluster-distance space.
+
+            In the new space, each dimension is the distance to the cluster
+            centers. Note that even if X is sparse, the array returned by
+            `transform` will typically be dense.
+
+            Parameters
+            ----------
+            X : {array-like, sparse matrix} of shape (n_samples, n_features)
+                New data to transform.
+
+            Returns
+            -------
+            X_new : ndarray of shape (n_samples, n_clusters)
+                X transformed in the new space.
+            """
+            check_is_fitted(self)
+
+            X = self._check_test_data(X)
+            return self._transform(X)
+
+else:
+    from daal4py.sklearn.cluster import KMeans
+
+    logging.warning(
+        "Preview KMeans requires oneDAL version >= 2023.2 " "but it was not found"
+    )

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview/decomposition/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+from .pca import PCA
+
+__all__ = ["PCA"]