scikit-learn-intelex 2025.0.1__py312-none-win_amd64.whl → 2025.2.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/svm/svc.py

@@ -18,8 +18,12 @@ 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.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
@@ -34,15 +38,20 @@ if sklearn_check_version("1.0"):
 
 from onedal.svm import SVC as onedal_SVC
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseSVC._validate_data
+
 
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
-class SVC(sklearn_SVC, BaseSVC):
-    __doc__ = sklearn_SVC.__doc__
+class SVC(_sklearn_SVC, BaseSVC):
+    __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__(
@@ -96,14 +105,12 @@ class SVC(sklearn_SVC, BaseSVC):
             # Windows fatal exception: access violation
             # occurs
             raise ValueError("C <= 0")
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_SVC.fit,
+                "sklearn": _sklearn_SVC.fit,
             },
             X,
             y,
@@ -114,28 +121,26 @@ class SVC(sklearn_SVC, BaseSVC):
 
     @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,
@@ -144,7 +149,7 @@ class SVC(sklearn_SVC, BaseSVC):
 
     if sklearn_check_version("1.0"):
 
-        @available_if(sklearn_SVC._check_proba)
+        @available_if(_sklearn_SVC._check_proba)
         def predict_proba(self, X):
             """
             Compute probabilities of possible outcomes for samples in X.
@@ -172,9 +177,10 @@ class SVC(sklearn_SVC, BaseSVC):
             predict. Also, it will produce meaningless results on very small
             datasets.
             """
+            check_is_fitted(self)
             return self._predict_proba(X)
 
-        @available_if(sklearn_SVC._check_proba)
+        @available_if(_sklearn_SVC._check_proba)
         def predict_log_proba(self, X):
             """Compute log probabilities of possible outcomes for samples in X.
 
@@ -211,20 +217,21 @@ class SVC(sklearn_SVC, BaseSVC):
         @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_SVC.predict_proba.__doc__
+        predict_proba.__doc__ = _sklearn_SVC.predict_proba.__doc__
 
     @wrap_output_data
     def _predict_proba(self, X):
         sklearn_pred_proba = (
-            sklearn_SVC.predict_proba
+            _sklearn_SVC.predict_proba
             if sklearn_check_version("1.0")
-            else sklearn_SVC._predict_proba
+            else _sklearn_SVC._predict_proba
         )
 
         return dispatch(
@@ -239,19 +246,18 @@ class SVC(sklearn_SVC, 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_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__
@@ -330,6 +336,23 @@ class SVC(sklearn_SVC, BaseSVC):
         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,
+                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):
@@ -347,6 +370,22 @@ class SVC(sklearn_SVC, BaseSVC):
             return self.clf_prob.predict_proba(X)
 
     def _onedal_decision_function(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.decision_function(X, queue=queue)
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
@@ -354,7 +393,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-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/svm/svr.py

@@ -14,8 +14,9 @@
 # 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
@@ -24,13 +25,18 @@ from onedal.svm import SVR as onedal_SVR
 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
 
-@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(_sklearn_SVR, BaseSVR):
+    __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__(
@@ -76,14 +82,12 @@ class SVR(sklearn_SVR, BaseSVR):
             # Windows fatal exception: access violation
             # occurs
             raise ValueError("C <= 0")
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_SVR.fit,
+                "sklearn": _sklearn_SVR.fit,
             },
             X,
             y,
@@ -94,28 +98,26 @@ class SVR(sklearn_SVR, BaseSVR):
 
     @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):
-        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_SVR.score,
+                "sklearn": _sklearn_SVR.score,
             },
             X,
             y,
@@ -142,8 +144,24 @@ class SVR(sklearn_SVR, 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_SVR.fit.__doc__
-    predict.__doc__ = sklearn_SVR.predict.__doc__
-    score.__doc__ = sklearn_SVR.score.__doc__
+    fit.__doc__ = _sklearn_SVR.fit.__doc__
+    predict.__doc__ = _sklearn_SVR.predict.__doc__
+    score.__doc__ = _sklearn_SVR.score.__doc__