scikit-learn-intelex 2023.2.1__py38-none-win_amd64.whl → 2024.0.1__py38-none-win_amd64.whl

{scikit_learn_intelex-2023.2.1.data/data/Lib/site-packages/sklearnex/preview/decomposition → scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview}/__init__.py

@@ -1,20 +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.
-#===============================================================================
-
-from .pca import PCA
-
-__all__ = ['PCA']
+#!/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-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/preview/cluster/__init__.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,8 +13,8 @@
 # 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']
+__all__ = ["KMeans"]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/preview/cluster/_common.py

@@ -1,4 +1,4 @@
-# ===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,7 +12,7 @@
 # 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
 
@@ -23,7 +23,7 @@ def get_cluster_centers(self):
 
 def set_cluster_centers(self, value):
     self._cluster_centers_ = value
-    if hasattr(self, '_onedal_estimator'):
+    if hasattr(self, "_onedal_estimator"):
         self._onedal_estimator.cluster_centers_ = value
 
 
@@ -33,7 +33,7 @@ def get_labels(self):
 
 def set_labels(self, value):
     self._labels_ = value
-    if hasattr(self, '_onedal_estimator'):
+    if hasattr(self, "_onedal_estimator"):
         self._onedal_estimator.labels_ = value
 
 
@@ -43,7 +43,7 @@ def get_inertia(self):
 
 def set_inertia(self, value):
     self._inertia_ = value
-    if hasattr(self, '_onedal_estimator'):
+    if hasattr(self, "_onedal_estimator"):
         self._onedal_estimator.inertia_ = value
 
 
@@ -53,7 +53,7 @@ def get_n_iter(self):
 
 def set_n_iter(self, value):
     self._n_iter_ = value
-    if hasattr(self, '_onedal_estimator'):
+    if hasattr(self, "_onedal_estimator"):
         self._onedal_estimator.n_iter_ = value
 
 
@@ -67,7 +67,7 @@ class BaseKMeans(ABC):
         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._algorithm = self._onedal_estimator.algorithm
         self._cluster_centers_ = self._onedal_estimator.cluster_centers_
         self._sparse = False
 

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/preview/cluster/k_means.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,54 +13,51 @@
 # 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._utils import daal_check_version
 import logging
 
-if daal_check_version((2023, 'P', 200)):
+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 ._common import BaseKMeans
-    from ..._device_offload import dispatch, wrap_output_data
-
-    from onedal.cluster import KMeans as onedal_KMeans
     from sklearn.cluster import KMeans as sklearn_KMeans
-
-    from daal4py.sklearn._utils import (
-        sklearn_check_version,
-        PatchingConditionsChain)
-
+    from sklearn.utils._openmp_helpers import _openmp_effective_n_threads
     from sklearn.utils.validation import (
+        _deprecate_positional_args,
         _num_samples,
         check_is_fitted,
-        _deprecate_positional_args)
+    )
 
-    from sklearn.utils._openmp_helpers import _openmp_effective_n_threads
+    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}
+        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',
+                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',
+                algorithm="lloyd",
             ):
                 super().__init__(
                     n_clusters=n_clusters,
@@ -73,20 +70,22 @@ if daal_check_version((2023, 'P', 200)):
                     copy_x=copy_x,
                     algorithm=algorithm,
                 )
-        elif sklearn_check_version('1.0'):
+
+        elif sklearn_check_version("1.0"):
+
             @_deprecate_positional_args
             def __init__(
                 self,
                 n_clusters=8,
                 *,
-                init='k-means++',
+                init="k-means++",
                 n_init=10,
                 max_iter=300,
                 tol=1e-4,
                 verbose=0,
                 random_state=None,
                 copy_x=True,
-                algorithm='auto',
+                algorithm="auto",
             ):
                 super().__init__(
                     n_clusters=n_clusters,
@@ -99,22 +98,24 @@ if daal_check_version((2023, 'P', 200)):
                     copy_x=copy_x,
                     algorithm=algorithm,
                 )
+
         else:
+
             @_deprecate_positional_args
             def __init__(
                 self,
                 n_clusters=8,
                 *,
-                init='k-means++',
+                init="k-means++",
                 n_init=10,
                 max_iter=300,
                 tol=1e-4,
-                precompute_distances='deprecated',
+                precompute_distances="deprecated",
                 verbose=0,
                 random_state=None,
                 copy_x=True,
-                n_jobs='deprecated',
-                algorithm='auto',
+                n_jobs="deprecated",
+                algorithm="auto",
             ):
                 super().__init__(
                     n_clusters=n_clusters,
@@ -132,38 +133,42 @@ if daal_check_version((2023, 'P', 200)):
 
         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,
+                "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'
+            assert method_name == "fit"
 
             class_name = self.__class__.__name__
-            patching_status = PatchingConditionsChain(
-                f'sklearn.cluster.{class_name}.fit')
+            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.'),
-            ])
+            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.get_status(logs=True)
+            return patching_status
 
         def fit(self, X, y=None, sample_weight=None):
             """Compute k-means clustering.
@@ -184,15 +189,22 @@ if daal_check_version((2023, 'P', 200)):
 
             """
 
-            if sklearn_check_version('1.0'):
+            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)
+            dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": sklearn_KMeans.fit,
+                },
+                X,
+                y,
+                sample_weight,
+            )
 
             return self
 
@@ -205,7 +217,10 @@ if daal_check_version((2023, 'P', 200)):
                 dtype=[np.float64, np.float32],
             )
 
-            self._check_params_vs_input(X)
+            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()
@@ -216,22 +231,28 @@ if daal_check_version((2023, 'P', 200)):
             self._save_attributes()
 
         def _onedal_predict_supported(self, method_name, X):
-            assert method_name == 'predict'
+            assert method_name == "predict"
 
             class_name = self.__class__.__name__
             patching_status = PatchingConditionsChain(
-                f'sklearn.cluster.{class_name}.predict')
+                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.')
-            ])
+            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.get_status(logs=True)
+            return patching_status
 
         @wrap_output_data
         def predict(self, X):
@@ -253,31 +274,39 @@ if daal_check_version((2023, 'P', 200)):
 
             """
 
-            if sklearn_check_version('1.0'):
+            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)
+            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)
-            if not hasattr(self, '_onedal_estimator'):
+            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':
+            if method_name == "fit":
                 return self._onedal_fit_supported(method_name, *data)
-            if method_name == 'predict':
+            if method_name == "predict":
                 return self._onedal_predict_supported(method_name, *data)
             raise RuntimeError(
-                f'Unknown method {method_name} in {self.__class__.__name__}')
+                f"Unknown method {method_name} in {self.__class__.__name__}"
+            )
 
         def _onedal_gpu_supported(self, method_name, *data):
             return self._onedal_supported(method_name, *data)
@@ -335,5 +364,7 @@ if daal_check_version((2023, 'P', 200)):
 
 else:
     from daal4py.sklearn.cluster import KMeans
-    logging.warning('Preview KMeans requires oneDAL version >= 2023.2 '
-                    'but it was not found')
+
+    logging.warning(
+        "Preview KMeans requires oneDAL version >= 2023.2 " "but it was not found"
+    )

scikit_learn_intelex-2023.2.1.data/data/Lib/site-packages/sklearnex/linear_model/linear.py → scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview/decomposition/__init__.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 # ===============================================================================
 # Copyright 2023 Intel Corporation
 #
@@ -14,4 +15,6 @@
 # limitations under the License.
 # ===============================================================================
 
-from daal4py.sklearn.linear_model import LinearRegression
+from .pca import PCA
+
+__all__ = ["PCA"]