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

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

@@ -31,33 +31,46 @@ from onedal.utils import _check_array, _check_X_y, _column_or_1d
 from .._config import config_context, get_config
 from .._utils import PatchingConditionsChain
 
-
-def get_dual_coef(self):
-    return self.dual_coef_
-
-
-def set_dual_coef(self, value):
-    self.dual_coef_ = value
-    if hasattr(self, "_onedal_estimator"):
-        self._onedal_estimator.dual_coef_ = value
-        if not self._is_in_fit:
-            del self._onedal_estimator._onedal_model
-
-
-def get_intercept(self):
-    return self._intercept_
-
-
-def set_intercept(self, value):
-    self._intercept_ = value
-    if hasattr(self, "_onedal_estimator"):
-        self._onedal_estimator.intercept_ = value
-        if not self._is_in_fit:
-            del self._onedal_estimator._onedal_model
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseEstimator._validate_data
 
 
 class BaseSVM(BaseEstimator, ABC):
 
+    @property
+    def _dual_coef_(self):
+        return self._dualcoef_
+
+    @_dual_coef_.setter
+    def _dual_coef_(self, value):
+        self._dualcoef_ = value
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.dual_coef_ = value
+            if hasattr(self._onedal_estimator, "_onedal_model"):
+                del self._onedal_estimator._onedal_model
+
+    @_dual_coef_.deleter
+    def _dual_coef_(self):
+        del self._dualcoef_
+
+    @property
+    def intercept_(self):
+        return self._icept_
+
+    @intercept_.setter
+    def intercept_(self, value):
+        self._icept_ = value
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.intercept_ = value
+            if hasattr(self._onedal_estimator, "_onedal_model"):
+                del self._onedal_estimator._onedal_model
+
+    @intercept_.deleter
+    def intercept_(self):
+        del self._icept_
+
     def _onedal_gpu_supported(self, method_name, *data):
         patching_status = PatchingConditionsChain(f"sklearn.{method_name}")
         patching_status.and_conditions([(False, "GPU offloading is not supported.")])
@@ -150,13 +163,23 @@ class BaseSVM(BaseEstimator, ABC):
                 )
         # using onedal _check_X_y to insure X and y are contiguous
         # finite check occurs in onedal estimator
-        X, y = _check_X_y(
-            X,
-            y,
-            dtype=[np.float64, np.float32],
-            force_all_finite=False,
-            accept_sparse="csr",
-        )
+        if sklearn_check_version("1.0"):
+            X, y = validate_data(
+                self,
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                accept_sparse="csr",
+            )
+        else:
+            X, y = _check_X_y(
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                accept_sparse="csr",
+            )
         y = self._validate_targets(y)
         sample_weight = self._get_sample_weight(X, y, sample_weight)
         return X, y, sample_weight
@@ -270,7 +293,7 @@ class BaseSVC(BaseSVM):
             self.class_weight_ = self._onedal_estimator.class_weight_
         self.support_ = self._onedal_estimator.support_
 
-        self._intercept_ = self._onedal_estimator.intercept_
+        self._icept_ = self._onedal_estimator.intercept_
         self._n_support = self._onedal_estimator._n_support
         self._sparse = False
         self._gamma = self._onedal_estimator._gamma
@@ -282,13 +305,7 @@ class BaseSVC(BaseSVM):
             self._probA = np.empty(0)
             self._probB = np.empty(0)
 
-        self._dual_coef_ = property(get_dual_coef, set_dual_coef)
-        self.intercept_ = property(get_intercept, set_intercept)
-
-        self._is_in_fit = True
-        self._dual_coef_ = self.dual_coef_
-        self.intercept_ = self._intercept_
-        self._is_in_fit = False
+        self._dualcoef_ = self.dual_coef_
 
         if sklearn_check_version("1.1"):
             length = int(len(self.classes_) * (len(self.classes_) - 1) / 2)
@@ -304,24 +321,18 @@ class BaseSVR(BaseSVM):
         self.shape_fit_ = self._onedal_estimator.shape_fit_
         self.support_ = self._onedal_estimator.support_
 
-        self._intercept_ = self._onedal_estimator.intercept_
+        self._icept_ = self._onedal_estimator.intercept_
         self._n_support = [self.support_vectors_.shape[0]]
         self._sparse = False
         self._gamma = self._onedal_estimator._gamma
         self._probA = None
         self._probB = None
 
-        self._dual_coef_ = property(get_dual_coef, set_dual_coef)
-        self.intercept_ = property(get_intercept, set_intercept)
-
-        self._is_in_fit = True
-        self._dual_coef_ = self.dual_coef_
-        self.intercept_ = self._intercept_
-        self._is_in_fit = False
-
         if sklearn_check_version("1.1"):
             self.n_iter_ = self._onedal_estimator.n_iter_
 
+        self._dualcoef_ = self.dual_coef_
+
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
         return r2_score(
             y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight

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

@@ -17,8 +17,12 @@
 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.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
@@ -32,15 +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
+
 
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
-class NuSVC(sklearn_NuSVC, BaseSVC):
-    __doc__ = sklearn_NuSVC.__doc__
+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__(
@@ -94,14 +103,12 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             # Windows fatal exception: access violation
             # occurs
             raise ValueError("nu <= 0 or nu > 1")
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_NuSVC.fit,
+                "sklearn": _sklearn_NuSVC.fit,
             },
             X,
             y,
@@ -112,28 +119,26 @@ class NuSVC(sklearn_NuSVC, 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_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,
@@ -142,7 +147,7 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
 
     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.
@@ -170,9 +175,10 @@ 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)
+        @available_if(_sklearn_NuSVC._check_proba)
         def predict_log_proba(self, X):
             """Compute log probabilities of possible outcomes for samples in X.
 
@@ -209,22 +215,21 @@ class NuSVC(sklearn_NuSVC, 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_NuSVC.predict_proba.__doc__
+        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(
@@ -239,19 +244,18 @@ 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__
+    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)
@@ -302,6 +306,24 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
         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):
@@ -319,6 +341,23 @@ 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):
@@ -326,7 +365,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-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/svm/nusvr.py

@@ -14,8 +14,13 @@
 # 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
@@ -24,13 +29,18 @@ 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
 
-@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(_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__(
@@ -76,14 +86,12 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
             # Windows fatal exception: access violation
             # occurs
             raise ValueError("nu <= 0 or nu > 1")
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
         dispatch(
             self,
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_NuSVR.fit,
+                "sklearn": _sklearn_NuSVR.fit,
             },
             X,
             y,
@@ -93,28 +101,26 @@ class NuSVR(sklearn_NuSVR, 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_NuSVR.predict,
+                "sklearn": _sklearn_NuSVR.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_NuSVR.score,
+                "sklearn": _sklearn_NuSVR.score,
             },
             X,
             y,
@@ -141,8 +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__
+    fit.__doc__ = _sklearn_NuSVR.fit.__doc__
+    predict.__doc__ = _sklearn_NuSVR.predict.__doc__
+    score.__doc__ = _sklearn_NuSVR.score.__doc__