scikit-learn-intelex 2024.2.0__py312-none-manylinux1_x86_64.whl → 2024.4.0__py312-none-manylinux1_x86_64.whl

sklearnex/svm/nusvc.py

@@ -14,12 +14,15 @@
 # limitations under the License.
 # ==============================================================================
 
+import numpy as np
 from sklearn.exceptions import NotFittedError
+from sklearn.metrics import accuracy_score
 from sklearn.svm import NuSVC as sklearn_NuSVC
 from sklearn.utils.validation import _deprecate_positional_args
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from sklearnex.utils import get_namespace
 
 from .._device_offload import dispatch, wrap_output_data
 from ._common import BaseSVC
@@ -31,7 +34,7 @@ from onedal.svm import NuSVC as onedal_NuSVC
 
 
 @control_n_jobs(
-    decorated_methods=["fit", "predict", "_predict_proba", "decision_function"]
+    decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
 class NuSVC(sklearn_NuSVC, BaseSVC):
     __doc__ = sklearn_NuSVC.__doc__
@@ -78,39 +81,6 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
         )
 
     def fit(self, X, y, sample_weight=None):
-        """
-        Fit the SVM model according to the given training data.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features) \
-                or (n_samples, n_samples)
-            Training vectors, where `n_samples` is the number of samples
-            and `n_features` is the number of features.
-            For kernel="precomputed", the expected shape of X is
-            (n_samples, n_samples).
-
-        y : array-like of shape (n_samples,)
-            Target values (class labels in classification, real numbers in
-            regression).
-
-        sample_weight : array-like of shape (n_samples,), default=None
-            Per-sample weights. Rescale C per sample. Higher weights
-            force the classifier to put more emphasis on these points.
-
-        Returns
-        -------
-        self : object
-            Fitted estimator.
-
-        Notes
-        -----
-        If X and y are not C-ordered and contiguous arrays of np.float64 and
-        X is not a scipy.sparse.csr_matrix, X and/or y may be copied.
-
-        If X is a dense array, then the other methods will not support sparse
-        matrices as input.
-        """
         if sklearn_check_version("1.2"):
             self._validate_params()
         if sklearn_check_version("1.0"):
@@ -131,22 +101,6 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
 
     @wrap_output_data
     def predict(self, X):
-        """
-        Perform regression on samples in X.
-
-        For an one-class model, +1 (inlier) or -1 (outlier) is returned.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            For kernel="precomputed", the expected shape of X is
-            (n_samples_test, n_samples_train).
-
-        Returns
-        -------
-        y_pred : ndarray of shape (n_samples,)
-            The predicted values.
-        """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
         return dispatch(
@@ -159,6 +113,22 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             X,
         )
 
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        if sklearn_check_version("1.0"):
+            self._check_feature_names(X, reset=False)
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": sklearn_NuSVC.score,
+            },
+            X,
+            y,
+            sample_weight=sample_weight,
+        )
+
     if sklearn_check_version("1.0"):
 
         @available_if(sklearn_NuSVC._check_proba)
@@ -191,6 +161,38 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             """
             return self._predict_proba(X)
 
+        @available_if(sklearn_NuSVC._check_proba)
+        def predict_log_proba(self, X):
+            """Compute log probabilities of possible outcomes for samples in X.
+
+            The model need to have probability information computed at training
+            time: fit with attribute `probability` set to True.
+
+            Parameters
+            ----------
+            X : array-like of shape (n_samples, n_features) or \
+                    (n_samples_test, n_samples_train)
+                For kernel="precomputed", the expected shape of X is
+                (n_samples_test, n_samples_train).
+
+            Returns
+            -------
+            T : ndarray of shape (n_samples, n_classes)
+                Returns the log-probabilities of the sample for each class in
+                the model. The columns correspond to the classes in sorted
+                order, as they appear in the attribute :term:`classes_`.
+
+            Notes
+            -----
+            The probability model is created using cross validation, so
+            the results can be slightly different than those obtained by
+            predict. Also, it will produce meaningless results on very small
+            datasets.
+            """
+            xp, _ = get_namespace(X)
+
+            return xp.log(self.predict_proba(X))
+
     else:
 
         @property
@@ -198,6 +200,12 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             self._check_proba()
             return self._predict_proba
 
+        def _predict_log_proba(self, X):
+            xp, _ = get_namespace(X)
+            return xp.log(self.predict_proba(X))
+
+        predict_proba.__doc__ = sklearn_NuSVC.predict_proba.__doc__
+
     @wrap_output_data
     def _predict_proba(self, X):
         if sklearn_check_version("1.0"):
@@ -232,6 +240,8 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             X,
         )
 
+    decision_function.__doc__ = sklearn_NuSVC.decision_function.__doc__
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
             "nu": self.nu,
@@ -274,3 +284,13 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
 
     def _onedal_decision_function(self, X, queue=None):
         return self._onedal_estimator.decision_function(X, queue=queue)
+
+    def _onedal_score(self, X, y, sample_weight=None, queue=None):
+        return accuracy_score(
+            y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
+        )
+
+    fit.__doc__ = sklearn_NuSVC.fit.__doc__
+    predict.__doc__ = sklearn_NuSVC.predict.__doc__
+    decision_function.__doc__ = sklearn_NuSVC.decision_function.__doc__
+    score.__doc__ = sklearn_NuSVC.score.__doc__

sklearnex/svm/nusvr.py

@@ -36,14 +36,14 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
     def __init__(
         self,
         *,
+        nu=0.5,
+        C=1.0,
         kernel="rbf",
         degree=3,
         gamma="scale",
         coef0=0.0,
-        tol=1e-3,
-        C=1.0,
-        nu=0.5,
         shrinking=True,
+        tol=1e-3,
         cache_size=200,
         verbose=False,
         max_iter=-1,
@@ -63,39 +63,6 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
         )
 
     def fit(self, X, y, sample_weight=None):
-        """
-        Fit the SVM model according to the given training data.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features) \
-                or (n_samples, n_samples)
-            Training vectors, where `n_samples` is the number of samples
-            and `n_features` is the number of features.
-            For kernel="precomputed", the expected shape of X is
-            (n_samples, n_samples).
-
-        y : array-like of shape (n_samples,)
-            Target values (class labels in classification, real numbers in
-            regression).
-
-        sample_weight : array-like of shape (n_samples,), default=None
-            Per-sample weights. Rescale C per sample. Higher weights
-            force the classifier to put more emphasis on these points.
-
-        Returns
-        -------
-        self : object
-            Fitted estimator.
-
-        Notes
-        -----
-        If X and y are not C-ordered and contiguous arrays of np.float64 and
-        X is not a scipy.sparse.csr_matrix, X and/or y may be copied.
-
-        If X is a dense array, then the other methods will not support sparse
-        matrices as input.
-        """
         if sklearn_check_version("1.2"):
             self._validate_params()
         if sklearn_check_version("1.0"):
@@ -115,22 +82,6 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
 
     @wrap_output_data
     def predict(self, X):
-        """
-        Perform regression on samples in X.
-
-        For an one-class model, +1 (inlier) or -1 (outlier) is returned.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            For kernel="precomputed", the expected shape of X is
-            (n_samples_test, n_samples_train).
-
-        Returns
-        -------
-        y_pred : ndarray of shape (n_samples,)
-            The predicted values.
-        """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
         return dispatch(
@@ -163,3 +114,6 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
 
     def _onedal_predict(self, X, queue=None):
         return self._onedal_estimator.predict(X, queue=queue)
+
+    fit.__doc__ = sklearn_NuSVR.fit.__doc__
+    predict.__doc__ = sklearn_NuSVR.predict.__doc__

sklearnex/svm/svc.py

@@ -17,11 +17,13 @@
 import numpy as np
 from scipy import sparse as sp
 from sklearn.exceptions import NotFittedError
+from sklearn.metrics import accuracy_score
 from sklearn.svm import SVC as sklearn_SVC
 from sklearn.utils.validation import _deprecate_positional_args
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from sklearnex.utils import get_namespace
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
@@ -34,7 +36,7 @@ from onedal.svm import SVC as onedal_SVC
 
 
 @control_n_jobs(
-    decorated_methods=["fit", "predict", "_predict_proba", "decision_function"]
+    decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
 class SVC(sklearn_SVC, BaseSVC):
     __doc__ = sklearn_SVC.__doc__
@@ -81,39 +83,6 @@ class SVC(sklearn_SVC, BaseSVC):
         )
 
     def fit(self, X, y, sample_weight=None):
-        """
-        Fit the SVM model according to the given training data.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features) \
-                or (n_samples, n_samples)
-            Training vectors, where `n_samples` is the number of samples
-            and `n_features` is the number of features.
-            For kernel="precomputed", the expected shape of X is
-            (n_samples, n_samples).
-
-        y : array-like of shape (n_samples,)
-            Target values (class labels in classification, real numbers in
-            regression).
-
-        sample_weight : array-like of shape (n_samples,), default=None
-            Per-sample weights. Rescale C per sample. Higher weights
-            force the classifier to put more emphasis on these points.
-
-        Returns
-        -------
-        self : object
-            Fitted estimator.
-
-        Notes
-        -----
-        If X and y are not C-ordered and contiguous arrays of np.float64 and
-        X is not a scipy.sparse.csr_matrix, X and/or y may be copied.
-
-        If X is a dense array, then the other methods will not support sparse
-        matrices as input.
-        """
         if sklearn_check_version("1.2"):
             self._validate_params()
         if sklearn_check_version("1.0"):
@@ -133,22 +102,6 @@ class SVC(sklearn_SVC, BaseSVC):
 
     @wrap_output_data
     def predict(self, X):
-        """
-        Perform regression on samples in X.
-
-        For an one-class model, +1 (inlier) or -1 (outlier) is returned.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            For kernel="precomputed", the expected shape of X is
-            (n_samples_test, n_samples_train).
-
-        Returns
-        -------
-        y_pred : ndarray of shape (n_samples,)
-            The predicted values.
-        """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
         return dispatch(
@@ -161,6 +114,22 @@ class SVC(sklearn_SVC, BaseSVC):
             X,
         )
 
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        if sklearn_check_version("1.0"):
+            self._check_feature_names(X, reset=False)
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": sklearn_SVC.score,
+            },
+            X,
+            y,
+            sample_weight=sample_weight,
+        )
+
     if sklearn_check_version("1.0"):
 
         @available_if(sklearn_SVC._check_proba)
@@ -193,6 +162,38 @@ class SVC(sklearn_SVC, BaseSVC):
             """
             return self._predict_proba(X)
 
+        @available_if(sklearn_SVC._check_proba)
+        def predict_log_proba(self, X):
+            """Compute log probabilities of possible outcomes for samples in X.
+
+            The model need to have probability information computed at training
+            time: fit with attribute `probability` set to True.
+
+            Parameters
+            ----------
+            X : array-like of shape (n_samples, n_features) or \
+                    (n_samples_test, n_samples_train)
+                For kernel="precomputed", the expected shape of X is
+                (n_samples_test, n_samples_train).
+
+            Returns
+            -------
+            T : ndarray of shape (n_samples, n_classes)
+                Returns the log-probabilities of the sample for each class in
+                the model. The columns correspond to the classes in sorted
+                order, as they appear in the attribute :term:`classes_`.
+
+            Notes
+            -----
+            The probability model is created using cross validation, so
+            the results can be slightly different than those obtained by
+            predict. Also, it will produce meaningless results on very small
+            datasets.
+            """
+            xp, _ = get_namespace(X)
+
+            return xp.log(self.predict_proba(X))
+
     else:
 
         @property
@@ -200,6 +201,12 @@ class SVC(sklearn_SVC, BaseSVC):
             self._check_proba()
             return self._predict_proba
 
+        def _predict_log_proba(self, X):
+            xp, _ = get_namespace(X)
+            return xp.log(self.predict_proba(X))
+
+        predict_proba.__doc__ = sklearn_SVC.predict_proba.__doc__
+
     @wrap_output_data
     def _predict_proba(self, X):
         sklearn_pred_proba = (
@@ -232,6 +239,8 @@ class SVC(sklearn_SVC, BaseSVC):
             X,
         )
 
+    decision_function.__doc__ = sklearn_SVC.decision_function.__doc__
+
     def _onedal_gpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
         patching_status = PatchingConditionsChain(
@@ -253,7 +262,7 @@ class SVC(sklearn_SVC, BaseSVC):
         if method_name == "fit":
             patching_status.and_conditions(conditions)
             return patching_status
-        if method_name in ["predict", "predict_proba", "decision_function"]:
+        if method_name in ["predict", "predict_proba", "decision_function", "score"]:
             conditions.append(
                 (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained")
             )
@@ -303,3 +312,13 @@ class SVC(sklearn_SVC, BaseSVC):
 
     def _onedal_decision_function(self, X, queue=None):
         return self._onedal_estimator.decision_function(X, queue=queue)
+
+    def _onedal_score(self, X, y, sample_weight=None, queue=None):
+        return accuracy_score(
+            y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
+        )
+
+    fit.__doc__ = sklearn_SVC.fit.__doc__
+    predict.__doc__ = sklearn_SVC.predict.__doc__
+    decision_function.__doc__ = sklearn_SVC.decision_function.__doc__
+    score.__doc__ = sklearn_SVC.score.__doc__

sklearnex/svm/svr.py

@@ -63,39 +63,6 @@ class SVR(sklearn_SVR, BaseSVR):
         )
 
     def fit(self, X, y, sample_weight=None):
-        """
-        Fit the SVM model according to the given training data.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features) \
-                or (n_samples, n_samples)
-            Training vectors, where `n_samples` is the number of samples
-            and `n_features` is the number of features.
-            For kernel="precomputed", the expected shape of X is
-            (n_samples, n_samples).
-
-        y : array-like of shape (n_samples,)
-            Target values (class labels in classification, real numbers in
-            regression).
-
-        sample_weight : array-like of shape (n_samples,), default=None
-            Per-sample weights. Rescale C per sample. Higher weights
-            force the classifier to put more emphasis on these points.
-
-        Returns
-        -------
-        self : object
-            Fitted estimator.
-
-        Notes
-        -----
-        If X and y are not C-ordered and contiguous arrays of np.float64 and
-        X is not a scipy.sparse.csr_matrix, X and/or y may be copied.
-
-        If X is a dense array, then the other methods will not support sparse
-        matrices as input.
-        """
         if sklearn_check_version("1.2"):
             self._validate_params()
         if sklearn_check_version("1.0"):
@@ -116,22 +83,6 @@ class SVR(sklearn_SVR, BaseSVR):
 
     @wrap_output_data
     def predict(self, X):
-        """
-        Perform regression on samples in X.
-
-        For an one-class model, +1 (inlier) or -1 (outlier) is returned.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            For kernel="precomputed", the expected shape of X is
-            (n_samples_test, n_samples_train).
-
-        Returns
-        -------
-        y_pred : ndarray of shape (n_samples,)
-            The predicted values.
-        """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
         return dispatch(
@@ -164,3 +115,6 @@ class SVR(sklearn_SVR, BaseSVR):
 
     def _onedal_predict(self, X, queue=None):
         return self._onedal_estimator.predict(X, queue=queue)
+
+    fit.__doc__ = sklearn_SVR.fit.__doc__
+    predict.__doc__ = sklearn_SVR.predict.__doc__

sklearnex/tests/_utils.py

@@ -0,0 +1,164 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from inspect import isclass
+
+import numpy as np
+from sklearn.base import (
+    BaseEstimator,
+    ClassifierMixin,
+    ClusterMixin,
+    OutlierMixin,
+    RegressorMixin,
+    TransformerMixin,
+)
+from sklearn.datasets import load_diabetes, load_iris
+from sklearn.neighbors._base import KNeighborsMixin
+
+from onedal.tests.utils._dataframes_support import _convert_to_dataframe
+from sklearnex import get_patch_map, patch_sklearn, sklearn_is_patched, unpatch_sklearn
+from sklearnex.linear_model import LogisticRegression
+from sklearnex.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    LocalOutlierFactor,
+    NearestNeighbors,
+)
+from sklearnex.svm import SVC, NuSVC
+
+
+def _load_all_models(with_sklearnex=True, estimator=True):
+    # insure that patch state is correct as dictated by patch_sklearn boolean
+    # and return it to the previous state no matter what occurs.
+    already_patched_map = sklearn_is_patched(return_map=True)
+    already_patched = any(already_patched_map.values())
+    try:
+        if with_sklearnex:
+            patch_sklearn()
+        elif already_patched:
+            unpatch_sklearn()
+
+        models = {}
+        for patch_infos in get_patch_map().values():
+            candidate = getattr(patch_infos[0][0][0], patch_infos[0][0][1], None)
+            if candidate is not None and isclass(candidate) == estimator:
+                if not estimator or issubclass(candidate, BaseEstimator):
+                    models[patch_infos[0][0][1]] = candidate
+    finally:
+        if with_sklearnex:
+            unpatch_sklearn()
+        # both branches are now in an unpatched state, repatch as necessary
+        if already_patched:
+            patch_sklearn(name=[i for i in already_patched_map if already_patched_map[i]])
+
+    return models
+
+
+PATCHED_MODELS = _load_all_models(with_sklearnex=True)
+UNPATCHED_MODELS = _load_all_models(with_sklearnex=False)
+
+PATCHED_FUNCTIONS = _load_all_models(with_sklearnex=True, estimator=False)
+UNPATCHED_FUNCTIONS = _load_all_models(with_sklearnex=False, estimator=False)
+
+mixin_map = [
+    [
+        ClassifierMixin,
+        ["decision_function", "predict", "predict_proba", "predict_log_proba", "score"],
+        "classification",
+    ],
+    [RegressorMixin, ["predict", "score"], "regression"],
+    [ClusterMixin, ["fit_predict"], "classification"],
+    [TransformerMixin, ["fit_transform", "transform", "score"], "classification"],
+    [OutlierMixin, ["fit_predict", "predict"], "classification"],
+    [KNeighborsMixin, ["kneighbors"], None],
+]
+
+
+SPECIAL_INSTANCES = {
+    str(i): i
+    for i in [
+        LocalOutlierFactor(novelty=True),
+        SVC(probability=True),
+        NuSVC(probability=True),
+        KNeighborsClassifier(algorithm="brute"),
+        KNeighborsRegressor(algorithm="brute"),
+        NearestNeighbors(algorithm="brute"),
+        LogisticRegression(solver="newton-cg"),
+    ]
+}
+
+
+def gen_models_info(algorithms):
+    output = []
+    for i in algorithms:
+
+        if i in PATCHED_MODELS:
+            est = PATCHED_MODELS[i]
+        elif i in SPECIAL_INSTANCES:
+            est = SPECIAL_INSTANCES[i].__class__
+        else:
+            raise KeyError(f"Unrecognized sklearnex estimator: {i}")
+
+        methods = set()
+        candidates = set(
+            [i for i in dir(est) if not i.startswith("_") and not i.endswith("_")]
+        )
+
+        for mixin, method, _ in mixin_map:
+            if issubclass(est, mixin):
+                methods |= candidates & set(method)
+
+        output += [[i, j] for j in methods] if methods else [[i, None]]
+
+    # In the case that no methods are available, set method to None.
+    # This will allow estimators without mixins to still test the fit
+    # method in various tests.
+    return output
+
+
+def gen_dataset(estimator, queue=None, target_df=None, dtype=np.float64):
+    dataset = None
+    name = estimator.__class__.__name__
+    est = PATCHED_MODELS[name]
+    for mixin, _, data in mixin_map:
+        if issubclass(est, mixin) and data is not None:
+            dataset = data
+    # load data
+    if dataset == "classification" or dataset is None:
+        X, y = load_iris(return_X_y=True)
+    elif dataset == "regression":
+        X, y = load_diabetes(return_X_y=True)
+    else:
+        raise ValueError("Unknown dataset type")
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    return X, y
+
+
+DTYPES = [
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.float16,
+    np.float32,
+    np.float64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+]