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

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

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,17 +12,15 @@
 # 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
 
 from onedal.spmd.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
 from onedal.spmd.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
 
-from ...preview.ensemble.forest import RandomForestClassifier as \
-    RandomForestClassifier_Batch
-from ...preview.ensemble.forest import RandomForestRegressor as \
-    RandomForestRegressor_Batch
+from ...ensemble import RandomForestClassifier as RandomForestClassifier_Batch
+from ...ensemble import RandomForestRegressor as RandomForestRegressor_Batch
 
 
 class BaseForestSPMD(ABC):
@@ -42,16 +40,18 @@ class RandomForestClassifier(BaseForestSPMD, RandomForestClassifier_Batch):
         ready = super()._onedal_cpu_supported(method_name, *data)
         if not ready:
             raise RuntimeError(
-                f'Method {method_name} in {self.__class__.__name__} '
-                'is not supported with given inputs.')
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
         return ready
 
     def _onedal_gpu_supported(self, method_name, *data):
         ready = super()._onedal_gpu_supported(method_name, *data)
         if not ready:
             raise RuntimeError(
-                f'Method {method_name} in {self.__class__.__name__} '
-                'is not supported with given inputs.')
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
         return ready
 
 
@@ -64,14 +64,16 @@ class RandomForestRegressor(BaseForestSPMD, RandomForestRegressor_Batch):
         ready = super()._onedal_cpu_supported(method_name, *data)
         if not ready:
             raise RuntimeError(
-                f'Method {method_name} in {self.__class__.__name__} '
-                'is not supported with given inputs.')
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
         return ready
 
     def _onedal_gpu_supported(self, method_name, *data):
         ready = super()._onedal_gpu_supported(method_name, *data)
         if not ready:
             raise RuntimeError(
-                f'Method {method_name} in {self.__class__.__name__} '
-                'is not supported with given inputs.')
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
         return ready

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

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,8 +12,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 .linear_model import LinearRegression
 
-__all__ = ['LinearRegression']
+__all__ = ["LinearRegression"]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/linear_model.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 onedal.spmd.linear_model import LinearRegression
 

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

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,8 +12,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 .neighbors import KNeighborsClassifier, KNeighborsRegressor, NearestNeighbors
 
-__all__ = ['KNeighborsClassifier', 'KNeighborsRegressor', 'NearestNeighbors']
+__all__ = ["KNeighborsClassifier", "KNeighborsRegressor", "NearestNeighbors"]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/neighbors/neighbors.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,12 +12,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#===============================================================================
+# ==============================================================================
 
 from onedal.spmd.neighbors import (
     KNeighborsClassifier,
     KNeighborsRegressor,
-    NearestNeighbors
+    NearestNeighbors,
 )
 
 # TODO:

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,15 +13,18 @@
 # 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 .._utils import get_sklearnex_version
-if get_sklearnex_version((2021, 'P', 300)):
-    from .svr import SVR
-    from .svc import SVC
-    from .nusvr import NuSVR
+
+if get_sklearnex_version((2021, "P", 300)):
     from .nusvc import NuSVC
-    __all__ = ['SVR', 'SVC', 'NuSVC', 'NuSVR']
+    from .nusvr import NuSVR
+    from .svc import SVC
+    from .svr import SVR
+
+    __all__ = ["SVR", "SVC", "NuSVC", "NuSVR"]
 else:
     from daal4py.sklearn.svm import SVC
-    __all__ = ['SVC']
+
+    __all__ = ["SVC"]

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

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,17 +12,19 @@
 # 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
-import numpy as np
-from daal4py.sklearn._utils import sklearn_check_version, PatchingConditionsChain
 
+import numpy as np
+from sklearn.calibration import CalibratedClassifierCV
 from sklearn.model_selection import StratifiedKFold
 from sklearn.preprocessing import LabelEncoder
-from sklearn.calibration import CalibratedClassifierCV
 
-from onedal.datatypes.validation import _column_or_1d
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal.utils import _column_or_1d
+
+from .._utils import PatchingConditionsChain
 
 
 def get_dual_coef(self):
@@ -31,7 +33,7 @@ def get_dual_coef(self):
 
 def set_dual_coef(self, value):
     self.dual_coef_ = value
-    if hasattr(self, '_onedal_estimator'):
+    if hasattr(self, "_onedal_estimator"):
         self._onedal_estimator.dual_coef_ = value
         if not self._is_in_fit:
             del self._onedal_estimator._onedal_model
@@ -43,7 +45,7 @@ def get_intercept(self):
 
 def set_intercept(self, value):
     self._intercept_ = value
-    if hasattr(self, '_onedal_estimator'):
+    if hasattr(self, "_onedal_estimator"):
         self._onedal_estimator.intercept_ = value
         if not self._is_in_fit:
             del self._onedal_estimator._onedal_model
@@ -51,31 +53,37 @@ def set_intercept(self, value):
 
 class BaseSVM(ABC):
     def _onedal_gpu_supported(self, method_name, *data):
-        patching_status = PatchingConditionsChain(f'sklearn.{method_name}')
-        patching_status.and_conditions([
-            (False, 'GPU offloading is not supported.')
-        ])
-        return patching_status.get_status(logs=True)
+        patching_status = PatchingConditionsChain(f"sklearn.{method_name}")
+        patching_status.and_conditions([(False, "GPU offloading is not supported.")])
+        return patching_status
 
     def _onedal_cpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
         patching_status = PatchingConditionsChain(
-            f'sklearn.svm.{class_name}.{method_name}')
-        if method_name == 'fit':
-            patching_status.and_conditions([
-                (self.kernel in ['linear', 'rbf', 'poly', 'sigmoid'],
-                 f'Kernel is "{self.kernel}" while '
-                 '"linear", "rbf", "poly" and "sigmoid" are only supported.')
-            ])
-            return patching_status.get_status(logs=True)
-        inference_methods = ['predict'] if class_name.endswith('R') \
-            else ['predict', 'predict_proba', 'decision_function']
+            f"sklearn.svm.{class_name}.{method_name}"
+        )
+        if method_name == "fit":
+            patching_status.and_conditions(
+                [
+                    (
+                        self.kernel in ["linear", "rbf", "poly", "sigmoid"],
+                        f'Kernel is "{self.kernel}" while '
+                        '"linear", "rbf", "poly" and "sigmoid" are only supported.',
+                    )
+                ]
+            )
+            return patching_status
+        inference_methods = (
+            ["predict"]
+            if class_name.endswith("R")
+            else ["predict", "predict_proba", "decision_function"]
+        )
         if method_name in inference_methods:
-            patching_status.and_conditions([
-                (hasattr(self, '_onedal_estimator'), 'oneDAL model was not trained.')
-            ])
-            return patching_status.get_status(logs=True)
-        raise RuntimeError(f'Unknown method {method_name} in {class_name}')
+            patching_status.and_conditions(
+                [(hasattr(self, "_onedal_estimator"), "oneDAL model was not trained.")]
+            )
+            return patching_status
+        raise RuntimeError(f"Unknown method {method_name} in {class_name}")
 
 
 class BaseSVC(BaseSVM):
@@ -92,38 +100,30 @@ class BaseSVC(BaseSVM):
         return recip_freq[le.transform(classes)]
 
     def _fit_proba(self, X, y, sample_weight=None, queue=None):
-        from .._config import get_config, config_context
-
         params = self.get_params()
         params["probability"] = False
-        params["decision_function_shape"] = 'ovr'
+        params["decision_function_shape"] = "ovr"
         clf_base = self.__class__(**params)
 
-        # We use stock metaestimators below, so the only way
-        # to pass a queue is using config_context.
-        cfg = get_config()
-        cfg['target_offload'] = queue
-        with config_context(**cfg):
-            try:
-                n_splits = 5
-                n_jobs = n_splits if queue is None or queue.sycl_device.is_cpu else 1
-                cv = StratifiedKFold(
-                    n_splits=n_splits,
-                    shuffle=True,
-                    random_state=self.random_state)
-                if sklearn_check_version("0.24"):
-                    self.clf_prob = CalibratedClassifierCV(
-                        clf_base, ensemble=False, cv=cv, method='sigmoid',
-                        n_jobs=n_jobs)
-                else:
-                    self.clf_prob = CalibratedClassifierCV(
-                        clf_base, cv=cv, method='sigmoid')
-                self.clf_prob.fit(X, y, sample_weight)
-            except ValueError:
-                clf_base = clf_base.fit(X, y, sample_weight)
+        try:
+            n_splits = 5
+            n_jobs = n_splits if queue is None or queue.sycl_device.is_cpu else 1
+            cv = StratifiedKFold(
+                n_splits=n_splits, shuffle=True, random_state=self.random_state
+            )
+            if sklearn_check_version("0.24"):
                 self.clf_prob = CalibratedClassifierCV(
-                    clf_base, cv="prefit", method='sigmoid')
-                self.clf_prob.fit(X, y, sample_weight)
+                    clf_base, ensemble=False, cv=cv, method="sigmoid", n_jobs=n_jobs
+                )
+            else:
+                self.clf_prob = CalibratedClassifierCV(clf_base, cv=cv, method="sigmoid")
+            self.clf_prob.fit(X, y, sample_weight)
+        except ValueError:
+            clf_base = clf_base.fit(X, y, sample_weight)
+            self.clf_prob = CalibratedClassifierCV(
+                clf_base, cv="prefit", method="sigmoid"
+            )
+            self.clf_prob.fit(X, y, sample_weight)
 
     def _save_attributes(self):
         self.support_vectors_ = self._onedal_estimator.support_vectors_
@@ -157,7 +157,7 @@ class BaseSVC(BaseSVM):
 
         if sklearn_check_version("1.1"):
             length = int(len(self.classes_) * (len(self.classes_) - 1) / 2)
-            self.n_iter_ = np.full((length, ), self._onedal_estimator.n_iter_)
+            self.n_iter_ = np.full((length,), self._onedal_estimator.n_iter_)
 
 
 class BaseSVR(BaseSVM):

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/svm/nusvc.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,16 +12,18 @@
 # 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 sklearn.exceptions import NotFittedError
+from sklearn.svm import NuSVC as sklearn_NuSVC
+from sklearn.utils.validation import _deprecate_positional_args
 
 from daal4py.sklearn._utils import sklearn_check_version
-from ._common import BaseSVC
+
 from .._device_offload import dispatch, wrap_output_data
+from ._common import BaseSVC
 
-from sklearn.svm import NuSVC as sklearn_NuSVC
-from sklearn.utils.validation import _deprecate_positional_args
-from sklearn.exceptions import NotFittedError
-if sklearn_check_version('1.0'):
+if sklearn_check_version("1.0"):
     from sklearn.utils.metaestimators import available_if
 
 from onedal.svm import NuSVC as onedal_NuSVC
@@ -30,21 +32,46 @@ from onedal.svm import NuSVC as onedal_NuSVC
 class NuSVC(sklearn_NuSVC, BaseSVC):
     __doc__ = sklearn_NuSVC.__doc__
 
-    if sklearn_check_version('1.2'):
+    if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**sklearn_NuSVC._parameter_constraints}
 
     @_deprecate_positional_args
-    def __init__(self, *, nu=0.5, kernel='rbf', degree=3, gamma='scale',
-                 coef0=0.0, shrinking=True, probability=False,
-                 tol=1e-3, cache_size=200, class_weight=None,
-                 verbose=False, max_iter=-1, decision_function_shape='ovr',
-                 break_ties=False, random_state=None):
+    def __init__(
+        self,
+        *,
+        nu=0.5,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        shrinking=True,
+        probability=False,
+        tol=1e-3,
+        cache_size=200,
+        class_weight=None,
+        verbose=False,
+        max_iter=-1,
+        decision_function_shape="ovr",
+        break_ties=False,
+        random_state=None,
+    ):
         super().__init__(
-            nu=nu, kernel=kernel, degree=degree, gamma=gamma, coef0=coef0,
-            shrinking=shrinking, probability=probability, tol=tol, cache_size=cache_size,
-            class_weight=class_weight, verbose=verbose, max_iter=max_iter,
-            decision_function_shape=decision_function_shape, break_ties=break_ties,
-            random_state=random_state)
+            nu=nu,
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            shrinking=shrinking,
+            probability=probability,
+            tol=tol,
+            cache_size=cache_size,
+            class_weight=class_weight,
+            verbose=verbose,
+            max_iter=max_iter,
+            decision_function_shape=decision_function_shape,
+            break_ties=break_ties,
+            random_state=random_state,
+        )
 
     def fit(self, X, y, sample_weight=None):
         """
@@ -84,10 +111,17 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             self._validate_params()
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
-        dispatch(self, 'fit', {
-            'onedal': self.__class__._onedal_fit,
-            'sklearn': sklearn_NuSVC.fit,
-        }, X, y, sample_weight)
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": sklearn_NuSVC.fit,
+            },
+            X,
+            y,
+            sample_weight,
+        )
 
         return self
 
@@ -111,12 +145,18 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
         """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
-        return dispatch(self, 'predict', {
-            'onedal': self.__class__._onedal_predict,
-            'sklearn': sklearn_NuSVC.predict,
-        }, X)
+        return dispatch(
+            self,
+            "predict",
+            {
+                "onedal": self.__class__._onedal_predict,
+                "sklearn": sklearn_NuSVC.predict,
+            },
+            X,
+        )
+
+    if sklearn_check_version("1.0"):
 
-    if sklearn_check_version('1.0'):
         @available_if(sklearn_NuSVC._check_proba)
         def predict_proba(self, X):
             """
@@ -146,7 +186,9 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             datasets.
             """
             return self._predict_proba(X)
+
     else:
+
         @property
         def predict_proba(self):
             self._check_proba()
@@ -156,38 +198,50 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
     def _predict_proba(self, X):
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
-        sklearn_pred_proba = (sklearn_NuSVC.predict_proba
-                              if sklearn_check_version("1.0")
-                              else sklearn_NuSVC._predict_proba)
-
-        return dispatch(self, 'predict_proba', {
-            'onedal': self.__class__._onedal_predict_proba,
-            'sklearn': sklearn_pred_proba,
-        }, X)
+        sklearn_pred_proba = (
+            sklearn_NuSVC.predict_proba
+            if sklearn_check_version("1.0")
+            else sklearn_NuSVC._predict_proba
+        )
+
+        return dispatch(
+            self,
+            "predict_proba",
+            {
+                "onedal": self.__class__._onedal_predict_proba,
+                "sklearn": sklearn_pred_proba,
+            },
+            X,
+        )
 
     @wrap_output_data
     def decision_function(self, X):
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
-        return dispatch(self, 'decision_function', {
-            'onedal': self.__class__._onedal_decision_function,
-            'sklearn': sklearn_NuSVC.decision_function,
-        }, X)
+        return dispatch(
+            self,
+            "decision_function",
+            {
+                "onedal": self.__class__._onedal_decision_function,
+                "sklearn": sklearn_NuSVC.decision_function,
+            },
+            X,
+        )
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
-            'nu': self.nu,
-            'kernel': self.kernel,
-            'degree': self.degree,
-            'gamma': self.gamma,
-            'coef0': self.coef0,
-            'tol': self.tol,
-            'shrinking': self.shrinking,
-            'cache_size': self.cache_size,
-            'max_iter': self.max_iter,
-            'class_weight': self.class_weight,
-            'break_ties': self.break_ties,
-            'decision_function_shape': self.decision_function_shape,
+            "nu": self.nu,
+            "kernel": self.kernel,
+            "degree": self.degree,
+            "gamma": self.gamma,
+            "coef0": self.coef0,
+            "tol": self.tol,
+            "shrinking": self.shrinking,
+            "cache_size": self.cache_size,
+            "max_iter": self.max_iter,
+            "class_weight": self.class_weight,
+            "break_ties": self.break_ties,
+            "decision_function_shape": self.decision_function_shape,
         }
 
         self._onedal_estimator = onedal_NuSVC(**onedal_params)
@@ -201,15 +255,16 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
         return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_predict_proba(self, X, queue=None):
-        if getattr(self, 'clf_prob', None) is None:
+        if getattr(self, "clf_prob", None) is None:
             raise NotFittedError(
-                "predict_proba is not available when fitted with probability=False")
-        from .._config import get_config, config_context
+                "predict_proba is not available when fitted with probability=False"
+            )
+        from .._config import config_context, get_config
 
         # We use stock metaestimators below, so the only way
         # to pass a queue is using config_context.
         cfg = get_config()
-        cfg['target_offload'] = queue
+        cfg["target_offload"] = queue
         with config_context(**cfg):
             return self.clf_prob.predict_proba(X)