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/svc.py

@@ -14,35 +14,39 @@
 # limitations under the License.
 # ==============================================================================
 
+from functools import wraps
+
 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 sklearn.svm import SVC as _sklearn_SVC
+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 SVC as onedal_SVC
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
+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 SVC as onedal_SVC
-
 
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
-class SVC(sklearn_SVC, BaseSVC):
-    __doc__ = sklearn_SVC.__doc__
+class SVC(BaseSVC, _sklearn_SVC):
+    __doc__ = _sklearn_SVC.__doc__
 
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_SVC._parameter_constraints}
+        _parameter_constraints: dict = {**_sklearn_SVC._parameter_constraints}
 
     @_deprecate_positional_args
     def __init__(
@@ -85,161 +89,98 @@ class SVC(sklearn_SVC, 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.C <= 0:
+            # 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("C <= 0")
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_SVC.fit,
+                "sklearn": _sklearn_SVC.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_SVC.predict,
+                "sklearn": _sklearn_SVC.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_SVC.score,
+                "sklearn": _sklearn_SVC.score,
             },
             X,
             y,
             sample_weight=sample_weight,
         )
 
-    if sklearn_check_version("1.0"):
-
-        @available_if(sklearn_SVC._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_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_`.
+    @available_if(_sklearn_SVC._check_proba)
+    @wraps(_sklearn_SVC.predict_proba, assigned=["__doc__"])
+    def predict_proba(self, X):
+        check_is_fitted(self)
+        return self._predict_proba(X)
 
-            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)
+    @available_if(_sklearn_SVC._check_proba)
+    @wraps(_sklearn_SVC.predict_log_proba, assigned=["__doc__"])
+    def predict_log_proba(self, X):
+        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_SVC.predict_proba.__doc__
+        return xp.log(self.predict_proba(X))
 
     @wrap_output_data
     def _predict_proba(self, X):
-        sklearn_pred_proba = (
-            sklearn_SVC.predict_proba
-            if sklearn_check_version("1.0")
-            else sklearn_SVC._predict_proba
-        )
-
         return dispatch(
             self,
             "predict_proba",
             {
                 "onedal": self.__class__._onedal_predict_proba,
-                "sklearn": sklearn_pred_proba,
+                "sklearn": _sklearn_SVC.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_SVC.decision_function,
+                "sklearn": _sklearn_SVC.decision_function,
             },
             X,
         )
 
-    decision_function.__doc__ = sklearn_SVC.decision_function.__doc__
+    decision_function.__doc__ = _sklearn_SVC.decision_function.__doc__
 
     def _onedal_gpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
@@ -270,12 +211,30 @@ class SVC(sklearn_SVC, BaseSVC):
             return patching_status
         raise RuntimeError(f"Unknown method {method_name} in {class_name}")
 
+    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
+
+        if np.any(sample_weight <= 0) and len(np.unique(y[sample_weight > 0])) != len(
+            self.classes_
+        ):
+            raise ValueError(
+                "Invalid input - all samples with positive weights "
+                "belong to the same class"
+                if sklearn_check_version("1.2")
+                else "Invalid input - all samples with positive weights "
+                "have the same label."
+            )
+        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 = {
             "C": self.C,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -287,13 +246,28 @@ class SVC(sklearn_SVC, BaseSVC):
         }
 
         self._onedal_estimator = onedal_SVC(**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):
+        X = 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):
@@ -311,6 +285,14 @@ class SVC(sklearn_SVC, BaseSVC):
             return self.clf_prob.predict_proba(X)
 
     def _onedal_decision_function(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.decision_function(X, queue=queue)
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
@@ -318,7 +300,7 @@ class SVC(sklearn_SVC, BaseSVC):
             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__
+    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__

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

@@ -14,23 +14,25 @@
 # limitations under the License.
 # ==============================================================================
 
-from sklearn.svm import SVR as sklearn_SVR
-from sklearn.utils.validation import _deprecate_positional_args
+import numpy as np
+from sklearn.svm import SVR as _sklearn_SVR
+from sklearn.utils.validation import _deprecate_positional_args, 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 SVR as onedal_SVR
 
 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 SVR(sklearn_SVR, BaseSVR):
-    __doc__ = sklearn_SVR.__doc__
+@control_n_jobs(decorated_methods=["fit", "predict", "score"])
+class SVR(BaseSVR, _sklearn_SVR):
+    __doc__ = _sklearn_SVR.__doc__
 
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_SVR._parameter_constraints}
+        _parameter_constraints: dict = {**_sklearn_SVR._parameter_constraints}
 
     @_deprecate_positional_args
     def __init__(
@@ -65,43 +67,67 @@ class SVR(sklearn_SVR, 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.C <= 0:
+            # 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("C <= 0")
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_SVR.fit,
+                "sklearn": _sklearn_SVR.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_SVR.predict,
+                "sklearn": _sklearn_SVR.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_SVR.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,
             "epsilon": self.epsilon,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -114,7 +140,16 @@ class SVR(sklearn_SVR, 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_SVR.fit.__doc__
-    predict.__doc__ = sklearn_SVR.predict.__doc__
+    fit.__doc__ = _sklearn_SVR.fit.__doc__
+    predict.__doc__ = _sklearn_SVR.predict.__doc__
+    score.__doc__ = _sklearn_SVR.score.__doc__

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

@@ -18,6 +18,11 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+try:
+    from scipy.sparse import csr_array as csr_class
+except ImportError:
+    from scipy.sparse import csr_matrix as csr_class
+
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
@@ -25,12 +30,10 @@ from onedal.tests.utils._dataframes_support import (
 )
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_svc(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("SVC fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import SVC
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
@@ -43,12 +46,10 @@ def test_sklearnex_import_svc(dataframe, queue):
     assert_allclose(_as_numpy(svc.support_), [1, 3])
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_nusvc(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("NuSVC fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import NuSVC
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
@@ -63,12 +64,10 @@ def test_sklearnex_import_nusvc(dataframe, queue):
     assert_allclose(_as_numpy(svc.support_), [0, 1, 3, 4])
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_svr(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("SVR fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import SVR
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
@@ -81,12 +80,10 @@ def test_sklearnex_import_svr(dataframe, queue):
     assert_allclose(_as_numpy(svc.support_), [1, 3])
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_nusvr(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("NuSVR fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import NuSVR
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
@@ -99,3 +96,29 @@ def test_sklearnex_import_nusvr(dataframe, queue):
         _as_numpy(svc.dual_coef_), [[-1.0, 0.611111, 1.0, -0.611111]], rtol=1e-3
     )
     assert_allclose(_as_numpy(svc.support_), [1, 2, 3, 5])
+
+
+# https://github.com/uxlfoundation/scikit-learn-intelex/issues/1880
+def test_works_with_unsorted_indices():
+    from sklearnex.svm import SVC
+
+    X = csr_class(
+        (
+            np.array(
+                [0.44943642, 0.6316672, 0.6316672, 0.44943642, 0.6316672, 0.6316672]
+            ),
+            np.array([1, 4, 3, 1, 2, 0], dtype=np.int32),
+            np.array([0, 3, 6], dtype=np.int32),
+        ),
+        shape=(2, 5),
+    )
+    y = np.array([1, 0])
+    X_test_single = np.array([[1, 0, 0, 0, 0]], dtype=np.float64)
+    X_test_multi = np.array([[1, 0, 0, 0, 0], [1, 0, 0, 0, 0]], dtype=np.float64)
+    model = SVC(probability=True).fit(X, y)
+    pred_single = model.predict_proba(X_test_single)
+    pred_multi = model.predict_proba(X_test_multi)[0]
+    np.testing.assert_array_equal(
+        pred_single.reshape(-1),
+        pred_multi.reshape(-1),
+    )