scikit-learn-intelex 2024.0.1__py311-none-win_amd64.whl → 2025.1.0__py311-none-win_amd64.whl

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

@@ -14,13 +14,21 @@
 # limitations under the License.
 # ==============================================================================
 
+import numpy as np
 from sklearn.exceptions import NotFittedError
-from sklearn.svm import NuSVC as sklearn_NuSVC
-from sklearn.utils.validation import _deprecate_positional_args
-
+from sklearn.metrics import accuracy_score
+from sklearn.svm import NuSVC as _sklearn_NuSVC
+from sklearn.utils.validation import (
+    _deprecate_positional_args,
+    check_array,
+    check_is_fitted,
+)
+
+from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils._array_api import get_namespace
 from ._common import BaseSVC
 
 if sklearn_check_version("1.0"):
@@ -28,12 +36,20 @@ if sklearn_check_version("1.0"):
 
 from onedal.svm import NuSVC as onedal_NuSVC
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseSVC._validate_data
+
 
-class NuSVC(sklearn_NuSVC, BaseSVC):
-    __doc__ = sklearn_NuSVC.__doc__
+@control_n_jobs(
+    decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
+)
+class NuSVC(_sklearn_NuSVC, BaseSVC):
+    __doc__ = _sklearn_NuSVC.__doc__
 
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_NuSVC._parameter_constraints}
+        _parameter_constraints: dict = {**_sklearn_NuSVC._parameter_constraints}
 
     @_deprecate_positional_args
     def __init__(
@@ -74,90 +90,64 @@ 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"):
-            self._check_feature_names(X, reset=True)
+        elif self.nu <= 0 or self.nu > 1:
+            # else if added to correct issues with
+            # sklearn tests:
+            # svm/tests/test_sparse.py::test_error
+            # svm/tests/test_svm.py::test_bad_input
+            # for sklearn versions < 1.2 (i.e. without
+            # validate_params parameter checking)
+            # Without this, a segmentation fault with
+            # Windows fatal exception: access violation
+            # occurs
+            raise ValueError("nu <= 0 or nu > 1")
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_NuSVC.fit,
+                "sklearn": _sklearn_NuSVC.fit,
             },
             X,
             y,
-            sample_weight,
+            sample_weight=sample_weight,
         )
 
         return self
 
     @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)
+        check_is_fitted(self)
         return dispatch(
             self,
             "predict",
             {
                 "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_NuSVC.predict,
+                "sklearn": _sklearn_NuSVC.predict,
             },
             X,
         )
 
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        check_is_fitted(self)
+        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)
+        @available_if(_sklearn_NuSVC._check_proba)
         def predict_proba(self, X):
             """
             Compute probabilities of possible outcomes for samples in X.
@@ -185,23 +175,61 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             predict. Also, it will produce meaningless results on very small
             datasets.
             """
+            check_is_fitted(self)
             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
         def predict_proba(self):
             self._check_proba()
+            check_is_fitted(self)
             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"):
-            self._check_feature_names(X, reset=False)
         sklearn_pred_proba = (
-            sklearn_NuSVC.predict_proba
+            _sklearn_NuSVC.predict_proba
             if sklearn_check_version("1.0")
-            else sklearn_NuSVC._predict_proba
+            else _sklearn_NuSVC._predict_proba
         )
 
         return dispatch(
@@ -216,24 +244,44 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
 
     @wrap_output_data
     def decision_function(self, X):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_is_fitted(self)
         return dispatch(
             self,
             "decision_function",
             {
                 "onedal": self.__class__._onedal_decision_function,
-                "sklearn": sklearn_NuSVC.decision_function,
+                "sklearn": _sklearn_NuSVC.decision_function,
             },
             X,
         )
 
+    decision_function.__doc__ = _sklearn_NuSVC.decision_function.__doc__
+
+    def _get_sample_weight(self, X, y, sample_weight=None):
+        sample_weight = super()._get_sample_weight(X, y, sample_weight)
+        if sample_weight is None:
+            return sample_weight
+
+        weight_per_class = [
+            np.sum(sample_weight[y == class_label]) for class_label in np.unique(y)
+        ]
+
+        for i in range(len(weight_per_class)):
+            for j in range(i + 1, len(weight_per_class)):
+                if self.nu * (weight_per_class[i] + weight_per_class[j]) / 2 > min(
+                    weight_per_class[i], weight_per_class[j]
+                ):
+                    raise ValueError("specified nu is infeasible")
+
+        return sample_weight
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        X, _, weights = self._onedal_fit_checks(X, y, sample_weight)
         onedal_params = {
             "nu": self.nu,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -245,13 +293,37 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
         }
 
         self._onedal_estimator = onedal_NuSVC(**onedal_params)
-        self._onedal_estimator.fit(X, y, sample_weight, queue=queue)
+        self._onedal_estimator.fit(X, y, weights, queue=queue)
 
         if self.probability:
-            self._fit_proba(X, y, sample_weight, queue=queue)
+            self._fit_proba(
+                X,
+                y,
+                sample_weight=sample_weight,
+                queue=queue,
+            )
+
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
+        if sklearn_check_version("1.0"):
+            validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                ensure_2d=False,
+                accept_sparse="csr",
+                reset=False,
+            )
+        else:
+            X = check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                accept_sparse="csr",
+            )
+
         return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_predict_proba(self, X, queue=None):
@@ -269,4 +341,31 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             return self.clf_prob.predict_proba(X)
 
     def _onedal_decision_function(self, X, queue=None):
+        if sklearn_check_version("1.0"):
+            validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                accept_sparse="csr",
+                reset=False,
+            )
+        else:
+            X = check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                accept_sparse="csr",
+            )
+
         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__

{scikit_learn_intelex-2024.0.1.data → scikit_learn_intelex-2025.1.0.data}/data/Lib/site-packages/sklearnex/svm/nusvr.py

@@ -14,34 +14,46 @@
 # limitations under the License.
 # ==============================================================================
 
-from sklearn.svm import NuSVR as sklearn_NuSVR
-from sklearn.utils.validation import _deprecate_positional_args
-
+import numpy as np
+from sklearn.svm import NuSVR as _sklearn_NuSVR
+from sklearn.utils.validation import (
+    _deprecate_positional_args,
+    check_array,
+    check_is_fitted,
+)
+
+from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import NuSVR as onedal_NuSVR
 
 from .._device_offload import dispatch, wrap_output_data
 from ._common import BaseSVR
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseSVR._validate_data
+
 
-class NuSVR(sklearn_NuSVR, BaseSVR):
-    __doc__ = sklearn_NuSVR.__doc__
+@control_n_jobs(decorated_methods=["fit", "predict", "score"])
+class NuSVR(_sklearn_NuSVR, BaseSVR):
+    __doc__ = _sklearn_NuSVR.__doc__
 
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_NuSVR._parameter_constraints}
+        _parameter_constraints: dict = {**_sklearn_NuSVR._parameter_constraints}
 
     @_deprecate_positional_args
     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,
@@ -61,93 +73,68 @@ 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"):
-            self._check_feature_names(X, reset=True)
+        elif self.nu <= 0 or self.nu > 1:
+            # else if added to correct issues with
+            # sklearn tests:
+            # svm/tests/test_sparse.py::test_error
+            # svm/tests/test_svm.py::test_bad_input
+            # for sklearn versions < 1.2 (i.e. without
+            # validate_params parameter checking)
+            # Without this, a segmentation fault with
+            # Windows fatal exception: access violation
+            # occurs
+            raise ValueError("nu <= 0 or nu > 1")
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_NuSVR.fit,
+                "sklearn": _sklearn_NuSVR.fit,
             },
             X,
             y,
-            sample_weight,
+            sample_weight=sample_weight,
         )
         return self
 
     @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)
+        check_is_fitted(self)
         return dispatch(
             self,
             "predict",
             {
                 "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_NuSVR.predict,
+                "sklearn": _sklearn_NuSVR.predict,
             },
             X,
         )
 
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        check_is_fitted(self)
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": _sklearn_NuSVR.score,
+            },
+            X,
+            y,
+            sample_weight=sample_weight,
+        )
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        X, _, sample_weight = self._onedal_fit_checks(X, y, sample_weight)
         onedal_params = {
             "C": self.C,
             "nu": self.nu,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -160,4 +147,24 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
+        if sklearn_check_version("1.0"):
+            X = validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                accept_sparse="csr",
+                reset=False,
+            )
+        else:
+            X = check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                accept_sparse="csr",
+            )
         return self._onedal_estimator.predict(X, queue=queue)
+
+    fit.__doc__ = _sklearn_NuSVR.fit.__doc__
+    predict.__doc__ = _sklearn_NuSVR.predict.__doc__
+    score.__doc__ = _sklearn_NuSVR.score.__doc__