scikit-learn-intelex 2025.4.0__py39-none-win_amd64.whl → 2025.5.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/ensemble/forest.py

@@ -24,13 +24,18 @@ from sklearn.ensemble import BaseEnsemble
 from sklearn.utils import check_random_state
 
 from daal4py.sklearn._utils import daal_check_version
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils import _sycl_queue_manager as QM
 from sklearnex import get_hyperparameters
 
-from ..common._base import BaseEstimator
+from .._config import _get_config
 from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin, RegressorMixin
 from ..datatypes import from_table, to_table
-from ..utils import (
+from ..utils._array_api import _get_sycl_namespace
+from ..utils._dpep_helpers import get_unique_values_with_dpep
+from ..utils.validation import (
     _check_array,
     _check_n_features,
     _check_X_y,
@@ -39,7 +44,7 @@ from ..utils import (
 )
 
 
-class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
+class BaseForest(BaseEnsemble, metaclass=ABCMeta):
     @abstractmethod
     def __init__(
         self,
@@ -96,6 +101,12 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         self.variable_importance_mode = variable_importance_mode
         self.algorithm = algorithm
 
+    @abstractmethod
+    def train(self, *args, **kwargs): ...
+
+    @abstractmethod
+    def infer(self, *args, **kwargs): ...
+
     def _to_absolute_max_features(self, n_features):
         if self.max_features is None:
             return n_features
@@ -288,27 +299,35 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
 
         return sample_weight
 
-    def _fit(self, X, y, sample_weight, module, queue):
-        X, y = _check_X_y(
-            X,
-            y,
-            dtype=[np.float64, np.float32],
-            force_all_finite=True,
-            accept_sparse="csr",
-        )
-        y = self._validate_targets(y, X.dtype)
+    def _fit(self, X, y, sample_weight):
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+
+        if not use_raw_input:
+            X, y = _check_X_y(
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                force_all_finite=True,
+                accept_sparse="csr",
+            )
+            y = self._validate_targets(y, X.dtype)
+        else:
+            if sua_iface is not None:
+                queue = X.sycl_queue
+            self.classes_ = get_unique_values_with_dpep(y)
 
         self.n_features_in_ = X.shape[1]
 
         if sample_weight is not None and len(sample_weight) > 0:
-            sample_weight = self._get_sample_weight(sample_weight, X)
+            if not use_raw_input:
+                sample_weight = self._get_sample_weight(sample_weight, X)
             data = (X, y, sample_weight)
         else:
             data = (X, y)
-        policy = self._get_policy(queue, *data)
-        data = to_table(*data, queue=queue)
+        data = to_table(*data, queue=QM.get_global_queue())
         params = self._get_onedal_params(data[0])
-        train_result = module.train(policy, params, *data)
+        train_result = self.train(params, *data)
 
         self._onedal_model = train_result.model
 
@@ -318,7 +337,7 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
                 self.oob_decision_function_ = from_table(
                     train_result.oob_err_decision_function
                 )
-                if np.any(self.oob_decision_function_ == 0):
+                if xp.any(self.oob_decision_function_ == 0):
                     warnings.warn(
                         "Some inputs do not have OOB scores. This probably means "
                         "too few trees were used to compute any reliable OOB "
@@ -345,44 +364,67 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         # upate error msg.
         raise NotImplementedError("Creating model is not supported.")
 
-    def _predict(self, X, module, queue, hparams=None):
+    def _predict(self, X, hparams=None):
         _check_is_fitted(self)
-        X = _check_array(
-            X, dtype=[np.float64, np.float32], force_all_finite=True, accept_sparse=False
-        )
-        _check_n_features(self, X, False)
-        policy = self._get_policy(queue, X)
+
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+
+        # All data should use the same sycl queue
+        if use_raw_input and sua_iface is not None:
+            queue = X.sycl_queue
+
+        if not use_raw_input:
+            X = _check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=True,
+                accept_sparse=False,
+            )
+            _check_n_features(self, X, False)
 
         model = self._onedal_model
+        queue = QM.get_global_queue()
         X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
         if hparams is not None and not hparams.is_default:
-            result = module.infer(policy, params, hparams.backend, model, X)
+            result = self.infer(params, hparams.backend, model, X)
         else:
-            result = module.infer(policy, params, model, X)
+            result = self.infer(params, model, X)
 
-        y = from_table(result.responses)
+        y = from_table(result.responses, sua_iface=sua_iface, sycl_queue=queue, xp=xp)
         return y
 
-    def _predict_proba(self, X, module, queue, hparams=None):
+    def _predict_proba(self, X, hparams=None):
         _check_is_fitted(self)
-        X = _check_array(
-            X, dtype=[np.float64, np.float32], force_all_finite=True, accept_sparse=False
-        )
-        _check_n_features(self, X, False)
-        policy = self._get_policy(queue, X)
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+
+        # All data should use the same sycl queue
+        if use_raw_input and sua_iface is not None:
+            queue = X.sycl_queue
+        else:
+            queue = QM.get_global_queue()
+
+        if not use_raw_input:
+            X = _check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=True,
+                accept_sparse=False,
+            )
+            _check_n_features(self, X, False)
         X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
         params["infer_mode"] = "class_probabilities"
 
         model = self._onedal_model
         if hparams is not None and not hparams.is_default:
-            result = module.infer(policy, params, hparams.backend, model, X)
+            result = self.infer(params, hparams.backend, model, X)
         else:
-            result = module.infer(policy, params, model, X)
+            result = self.infer(params, model, X)
 
-        y = from_table(result.probabilities)
-        return y
+        return from_table(result.probabilities)
 
 
 class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
@@ -443,6 +485,12 @@ class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
             algorithm=algorithm,
         )
 
+    @bind_default_backend("decision_forest.classification")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("decision_forest.classification")
+    def infer(self, *args, **kwargs): ...
+
     def _validate_targets(self, y, dtype):
         y, self.class_weight_, self.classes_ = _validate_targets(
             y, self.class_weight, dtype
@@ -455,35 +503,28 @@ class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
         #    self.n_classes_ = self.classes_
         return y
 
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
-        return self._fit(
-            X,
-            y,
-            sample_weight,
-            self._get_backend("decision_forest", "classification", None),
-            queue,
-        )
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
+        _, xp, _ = _get_sycl_namespace(X)
         hparams = get_hyperparameters("decision_forest", "infer")
-        pred = super()._predict(
-            X,
-            self._get_backend("decision_forest", "classification", None),
-            queue,
-            hparams,
-        )
+        pred = xp.reshape(self._predict(X, hparams), -1)
 
-        return np.take(self.classes_, pred.ravel().astype(np.int64, casting="unsafe"))
+        try:
+            return xp.take(
+                xp.asarray(self.classes_), xp.astype(xp.reshape(pred, (-1,)), xp.int64)
+            )
+        except AttributeError:
+            return np.take(self.classes_, pred.ravel().astype(np.int64, casting="unsafe"))
 
+    @supports_queue
     def predict_proba(self, X, queue=None):
         hparams = get_hyperparameters("decision_forest", "infer")
 
-        return super()._predict_proba(
-            X,
-            self._get_backend("decision_forest", "classification", None),
-            queue,
-            hparams,
-        )
+        return super()._predict_proba(X, hparams)
 
 
 class RandomForestRegressor(RegressorMixin, BaseForest, metaclass=ABCMeta):
@@ -544,25 +585,24 @@ class RandomForestRegressor(RegressorMixin, BaseForest, metaclass=ABCMeta):
             algorithm=algorithm,
         )
 
+    @bind_default_backend("decision_forest.regression")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("decision_forest.regression")
+    def infer(self, *args, **kwargs): ...
+
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
         if sample_weight is not None:
             if hasattr(sample_weight, "__array__"):
                 sample_weight[sample_weight == 0.0] = 1.0
             sample_weight = [sample_weight]
-        return super()._fit(
-            X,
-            y,
-            sample_weight,
-            self._get_backend("decision_forest", "regression", None),
-            queue,
-        )
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        return (
-            super()
-            ._predict(X, self._get_backend("decision_forest", "regression", None), queue)
-            .ravel()
-        )
+        _, xp, _ = _get_sycl_namespace(X)
+        return xp.reshape(self._predict(X), -1)
 
 
 class ExtraTreesClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
@@ -623,6 +663,12 @@ class ExtraTreesClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
             algorithm=algorithm,
         )
 
+    @bind_default_backend("decision_forest.classification")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("decision_forest.classification")
+    def infer(self, *args, **kwargs): ...
+
     def _validate_targets(self, y, dtype):
         y, self.class_weight_, self.classes_ = _validate_targets(
             y, self.class_weight, dtype
@@ -635,26 +681,19 @@ class ExtraTreesClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
         #    self.n_classes_ = self.classes_
         return y
 
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
-        return self._fit(
-            X,
-            y,
-            sample_weight,
-            self._get_backend("decision_forest", "classification", None),
-            queue,
-        )
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        pred = super()._predict(
-            X, self._get_backend("decision_forest", "classification", None), queue
-        )
+        pred = self._predict(X)
 
         return np.take(self.classes_, pred.ravel().astype(np.int64, casting="unsafe"))
 
+    @supports_queue
     def predict_proba(self, X, queue=None):
-        return super()._predict_proba(
-            X, self._get_backend("decision_forest", "classification", None), queue
-        )
+        return super()._predict_proba(X)
 
 
 class ExtraTreesRegressor(RegressorMixin, BaseForest, metaclass=ABCMeta):
@@ -715,22 +754,20 @@ class ExtraTreesRegressor(RegressorMixin, BaseForest, metaclass=ABCMeta):
             algorithm=algorithm,
         )
 
+    @bind_default_backend("decision_forest.regression")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("decision_forest.regression")
+    def infer(self, *args, **kwargs): ...
+
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
         if sample_weight is not None:
             if hasattr(sample_weight, "__array__"):
                 sample_weight[sample_weight == 0.0] = 1.0
             sample_weight = [sample_weight]
-        return super()._fit(
-            X,
-            y,
-            sample_weight,
-            self._get_backend("decision_forest", "regression", None),
-            queue,
-        )
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        return (
-            super()
-            ._predict(X, self._get_backend("decision_forest", "regression", None), queue)
-            .ravel()
-        )
+        return self._predict(X).ravel()

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -16,11 +16,15 @@
 
 import numpy as np
 
-from daal4py.sklearn._utils import get_dtype
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils import _sycl_queue_manager as QM
 
+from .._config import _get_config
 from ..common.hyperparameters import get_hyperparameters
 from ..datatypes import from_table, to_table
-from ..utils import _check_X_y, _num_features
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_X_y, _num_features
 from .linear_model import BaseLinearRegression
 
 
@@ -44,13 +48,23 @@ class IncrementalLinearRegression(BaseLinearRegression):
 
     def __init__(self, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
         super().__init__(fit_intercept=fit_intercept, copy_X=copy_X, algorithm=algorithm)
+        self._queue = None
         self._reset()
 
+    @bind_default_backend("linear_model.regression")
+    def partial_train_result(self): ...
+
+    @bind_default_backend("linear_model.regression")
+    def partial_train(self, *args, **kwargs): ...
+
+    @bind_default_backend("linear_model.regression")
+    def finalize_train(self, *args, **kwargs): ...
+
     def _reset(self):
         self._need_to_finalize = False
-        self._partial_result = self._get_backend(
-            "linear_model", "regression", "partial_train_result"
-        )
+        # Get the pointer to partial_result from backend
+        self._queue = None
+        self._partial_result = self.partial_train_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -63,6 +77,7 @@ class IncrementalLinearRegression(BaseLinearRegression):
 
         return data
 
+    @supports_queue
     def partial_fit(self, X, y, queue=None):
         """
         Computes partial data for linear regression
@@ -84,37 +99,37 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-        module = self._get_backend("linear_model", "regression")
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
+
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+        if not use_raw_input:
+            X, y = _check_X_y(
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                accept_2d_y=True,
+                force_all_finite=False,
+            )
+            y = np.asarray(y, dtype=X.dtype)
 
-        self._queue = queue
-        policy = self._get_policy(queue, X)
-
-        X, y = _check_X_y(
-            X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
-        )
-        y = np.asarray(y, dtype=X.dtype)
+        if not hasattr(self, "_params"):
+            self._params = self._get_onedal_params(X.dtype)
 
+        self._queue = queue
         self.n_features_in_ = _num_features(X, fallback_1d=True)
 
         X_table, y_table = to_table(X, y, queue=queue)
 
-        if not hasattr(self, "_dtype"):
-            self._dtype = X_table.dtype
-            self._params = self._get_onedal_params(self._dtype)
-
         hparams = get_hyperparameters("linear_regression", "train")
         if hparams is not None and not hparams.is_default:
-            self._partial_result = module.partial_train(
-                policy,
-                self._params,
-                hparams.backend,
-                self._partial_result,
-                X_table,
-                y_table,
+            self._partial_result = self.partial_train(
+                self._params, hparams.backend, self._partial_result, X_table, y_table
             )
         else:
-            self._partial_result = module.partial_train(
-                policy, self._params, self._partial_result, X_table, y_table
+            self._partial_result = self.partial_train(
+                self._params, self._partial_result, X_table, y_table
             )
 
         self._need_to_finalize = True
@@ -137,28 +152,24 @@ class IncrementalLinearRegression(BaseLinearRegression):
         """
 
         if self._need_to_finalize:
-            if queue is not None:
-                policy = self._get_policy(queue)
-            else:
-                policy = self._get_policy(self._queue)
-
-            module = self._get_backend("linear_model", "regression")
             hparams = get_hyperparameters("linear_regression", "train")
-            if hparams is not None and not hparams.is_default:
-                result = module.finalize_train(
-                    policy, self._params, hparams.backend, self._partial_result
-                )
-            else:
-                result = module.finalize_train(policy, self._params, self._partial_result)
+            with QM.manage_global_queue(self._queue):
+                if hparams is not None and not hparams.is_default:
+                    result = self.finalize_train(
+                        self._params, hparams.backend, self._partial_result
+                    )
+                else:
+                    result = self.finalize_train(self._params, self._partial_result)
 
             self._onedal_model = result.model
 
-            packed_coefficients = from_table(result.model.packed_coefficients)
+            packed_coefficients = from_table(
+                result.model.packed_coefficients, sycl_queue=self._queue
+            )
             self.coef_, self.intercept_ = (
                 packed_coefficients[:, 1:].squeeze(),
                 packed_coefficients[:, 0].squeeze(),
             )
-
             self._need_to_finalize = False
 
         return self
@@ -191,12 +202,13 @@ class IncrementalRidge(BaseLinearRegression):
         super().__init__(
             fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
         )
+        self._queue = None
         self._reset()
 
     def _reset(self):
-        module = self._get_backend("linear_model", "regression")
-        self._partial_result = module.partial_train_result()
         self._need_to_finalize = False
+        self._queue = None
+        self._partial_result = self.partial_train_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -209,6 +221,16 @@ class IncrementalRidge(BaseLinearRegression):
 
         return data
 
+    @bind_default_backend("linear_model.regression")
+    def partial_train_result(self): ...
+
+    @bind_default_backend("linear_model.regression")
+    def partial_train(self, *args, **kwargs): ...
+
+    @bind_default_backend("linear_model.regression")
+    def finalize_train(self, *args, **kwargs): ...
+
+    @supports_queue
     def partial_fit(self, X, y, queue=None):
         """
         Computes partial data for ridge regression
@@ -230,11 +252,7 @@ class IncrementalRidge(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-        module = self._get_backend("linear_model", "regression")
-
         self._queue = queue
-        policy = self._get_policy(queue, X)
-
         X, y = _check_X_y(
             X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
         )
@@ -248,9 +266,15 @@ class IncrementalRidge(BaseLinearRegression):
             self._dtype = X_table.dtype
             self._params = self._get_onedal_params(self._dtype)
 
-        self._partial_result = module.partial_train(
-            policy, self._params, self._partial_result, X_table, y_table
-        )
+        hparams = get_hyperparameters("linear_regression", "train")
+        if hparams is not None and not hparams.is_default:
+            self._partial_result = self.partial_train(
+                self._params, hparams.backend, self._partial_result, X_table, y_table
+            )
+        else:
+            self._partial_result = self.partial_train(
+                self._params, self._partial_result, X_table, y_table
+            )
 
         self._need_to_finalize = True
         return self
@@ -270,16 +294,11 @@ class IncrementalRidge(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-
         if self._need_to_finalize:
-            module = self._get_backend("linear_model", "regression")
-            if queue is not None:
-                policy = self._get_policy(queue)
-            else:
-                policy = self._get_policy(self._queue)
-            result = module.finalize_train(policy, self._params, self._partial_result)
+            with QM.manage_global_queue(self._queue):
+                result = self.finalize_train(self._params, self._partial_result)
 
-            self._onedal_model = result.model
+                self._onedal_model = result.model
 
             packed_coefficients = from_table(result.model.packed_coefficients)
             self.coef_, self.intercept_ = (