scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2025.10.0.data}/data/Lib/site-packages/sklearnex/svm/nusvc.py

@@ -14,33 +14,37 @@
 # limitations under the License.
 # ==============================================================================
 
+from functools import wraps
+
 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 sklearn.svm import NuSVC as _sklearn_NuSVC
+from sklearn.utils.metaestimators import available_if
+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 sklearnex.utils import get_namespace
+from onedal.svm import NuSVC as onedal_NuSVC
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils._array_api import get_namespace
+from ..utils.validation import validate_data
 from ._common import BaseSVC
 
-if sklearn_check_version("1.0"):
-    from sklearn.utils.metaestimators import available_if
-
-from onedal.svm import NuSVC as onedal_NuSVC
-
 
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
-class NuSVC(sklearn_NuSVC, BaseSVC):
-    __doc__ = sklearn_NuSVC.__doc__
+class NuSVC(BaseSVC, _sklearn_NuSVC):
+    __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__(
@@ -83,171 +87,124 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
     def fit(self, X, y, sample_weight=None):
         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):
-        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):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_is_fitted(self)
         return dispatch(
             self,
             "score",
             {
                 "onedal": self.__class__._onedal_score,
-                "sklearn": sklearn_NuSVC.score,
+                "sklearn": _sklearn_NuSVC.score,
             },
             X,
             y,
             sample_weight=sample_weight,
         )
 
-    if sklearn_check_version("1.0"):
-
-        @available_if(sklearn_NuSVC._check_proba)
-        def predict_proba(self, X):
-            """
-            Compute 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)
-                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 probability 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.
-            """
-            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()
-            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__
+    @available_if(_sklearn_NuSVC._check_proba)
+    @wraps(_sklearn_NuSVC.predict_proba, assigned=["__doc__"])
+    def predict_proba(self, X):
+        check_is_fitted(self)
+        return self._predict_proba(X)
+
+    @available_if(_sklearn_NuSVC._check_proba)
+    @wraps(_sklearn_NuSVC.predict_log_proba, assigned=["__doc__"])
+    def predict_log_proba(self, X):
+        xp, _ = get_namespace(X)
+
+        return xp.log(self.predict_proba(X))
 
     @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
-            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,
+                "sklearn": _sklearn_NuSVC.predict_proba,
             },
             X,
         )
 
     @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__
+    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,
@@ -259,13 +216,29 @@ 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):
+        validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            ensure_2d=False,
+            accept_sparse="csr",
+            reset=False,
+        )
+
         return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_predict_proba(self, X, queue=None):
@@ -283,6 +256,15 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             return self.clf_prob.predict_proba(X)
 
     def _onedal_decision_function(self, X, queue=None):
+        validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            accept_sparse="csr",
+            reset=False,
+        )
+
         return self._onedal_estimator.decision_function(X, queue=queue)
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
@@ -290,7 +272,7 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             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__
+    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.4.0.data → scikit_learn_intelex-2025.10.0.data}/data/Lib/site-packages/sklearnex/svm/nusvr.py

@@ -14,23 +14,29 @@
 # 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 ..utils.validation import validate_data
 from ._common import BaseSVR
 
 
-@control_n_jobs(decorated_methods=["fit", "predict"])
-class NuSVR(sklearn_NuSVR, BaseSVR):
-    __doc__ = sklearn_NuSVR.__doc__
+@control_n_jobs(decorated_methods=["fit", "predict", "score"])
+class NuSVR(BaseSVR, _sklearn_NuSVR):
+    __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__(
@@ -65,42 +71,66 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
     def fit(self, X, y, sample_weight=None):
         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):
-        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,
@@ -113,7 +143,16 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            accept_sparse="csr",
+            reset=False,
+        )
         return self._onedal_estimator.predict(X, queue=queue)
 
-    fit.__doc__ = sklearn_NuSVR.fit.__doc__
-    predict.__doc__ = sklearn_NuSVR.predict.__doc__
+    fit.__doc__ = _sklearn_NuSVR.fit.__doc__
+    predict.__doc__ = _sklearn_NuSVR.predict.__doc__
+    score.__doc__ = _sklearn_NuSVR.score.__doc__