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

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/decomposition/incremental_pca.py

@@ -16,10 +16,14 @@
 
 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 ..datatypes import from_table, to_table
-from ..utils import _check_array
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
 from .pca import BasePCA
 
 
@@ -96,14 +100,24 @@ class IncrementalPCA(BasePCA):
         self.method = method
         self.is_deterministic = is_deterministic
         self.whiten = whiten
+        self._queue = None
         self._reset()
 
+    @bind_default_backend("decomposition.dim_reduction")
+    def finalize_train(self, params, partial_result): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def partial_train(self, params, partial_result, X_table): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def partial_train_result(self): ...
+
     def _reset(self):
         self._need_to_finalize = False
-        module = self._get_backend("decomposition", "dim_reduction")
+        self._queue = None
+        self._partial_result = self.partial_train_result()
         if hasattr(self, "components_"):
             del self.components_
-        self._partial_result = module.partial_train_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -113,10 +127,10 @@ class IncrementalPCA(BasePCA):
         self.finalize_fit()
         data = self.__dict__.copy()
         data.pop("_queue", None)
-
         return data
 
-    def partial_fit(self, X, queue):
+    @supports_queue
+    def partial_fit(self, X, queue=None):
         """Incremental fit with X. All of X is processed as a single batch.
 
         Parameters
@@ -133,9 +147,17 @@ class IncrementalPCA(BasePCA):
         self : object
             Returns the instance itself.
         """
-        X = _check_array(X)
-        n_samples, n_features = X.shape
 
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
+
+        # All data should use the same sycl queue
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+        if not use_raw_input:
+            X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True)
+
+        n_samples, n_features = X.shape
         first_pass = not hasattr(self, "components_")
         if first_pass:
             self.components_ = None
@@ -154,26 +176,20 @@ class IncrementalPCA(BasePCA):
 
         self._queue = queue
 
-        policy = self._get_policy(queue, X)
         X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
             self._dtype = X_table.dtype
             self._params = self._get_onedal_params(X_table)
 
-        self._partial_result = self._get_backend(
-            "decomposition",
-            "dim_reduction",
-            "partial_train",
-            policy,
-            self._params,
-            self._partial_result,
-            X_table,
+        self._partial_result = self.partial_train(
+            self._params, self._partial_result, X_table
         )
         self._need_to_finalize = True
+        self._queue = queue
         return self
 
-    def finalize_fit(self, queue=None):
+    def finalize_fit(self):
         """
         Finalizes principal components computation and obtains resulting
         attributes from the current `_partial_result`.
@@ -189,12 +205,8 @@ class IncrementalPCA(BasePCA):
             Returns the instance itself.
         """
         if self._need_to_finalize:
-            module = self._get_backend("decomposition", "dim_reduction")
-            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.mean_ = from_table(result.means).ravel()
             self.var_ = from_table(result.variances).ravel()
             self.components_ = from_table(result.eigenvectors)
@@ -210,5 +222,7 @@ class IncrementalPCA(BasePCA):
             self.noise_variance_ = self._compute_noise_variance(
                 self.n_components_, min(self.n_samples_seen_, self.n_features_in_)
             )
-        self._need_to_finalize = False
+            self._need_to_finalize = False
+            self._queue = None
+
         return self

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/decomposition/pca.py

@@ -21,11 +21,15 @@ import numpy as np
 from sklearn.decomposition._pca import _infer_dimension
 from sklearn.utils.extmath import stable_cumsum
 
-from ..common._base import BaseEstimator
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+
+from .._config import _get_config
 from ..datatypes import from_table, to_table
+from ..utils._array_api import _get_sycl_namespace
 
 
-class BasePCA(BaseEstimator, metaclass=ABCMeta):
+class BasePCA(metaclass=ABCMeta):
     """
     Base class for PCA oneDAL implementation.
     """
@@ -42,6 +46,16 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
         self.is_deterministic = is_deterministic
         self.whiten = whiten
 
+    # provides direct access to the backend model constructor
+    @bind_default_backend("decomposition.dim_reduction")
+    def model(self): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def train(self, params, X): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def infer(self, params, X, model): ...
+
     def _get_onedal_params(self, data, stage=None):
         if stage is None:
             n_components = self._resolve_n_components_for_training(data.shape)
@@ -119,7 +133,7 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
             return 0.0
 
     def _create_model(self):
-        m = self._get_backend("decomposition", "dim_reduction", "model")
+        m = self.model()
         m.eigenvectors = to_table(self.components_)
         m.means = to_table(self.mean_)
         if self.whiten:
@@ -127,26 +141,30 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
         self._onedal_model = m
         return m
 
+    @supports_queue
     def predict(self, X, queue=None):
-        policy = self._get_policy(queue, X)
         model = self._create_model()
         X_table = to_table(X, queue=queue)
         params = self._get_onedal_params(X_table, stage="predict")
-
-        result = self._get_backend(
-            "decomposition", "dim_reduction", "infer", policy, params, model, X_table
-        )
+        result = self.infer(params, model, X_table)
         return from_table(result.transformed_data)
 
+    transform = predict
+
 
 class PCA(BasePCA):
 
+    @supports_queue
     def fit(self, X, y=None, queue=None):
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+
         n_samples, n_features = X.shape
         n_sf_min = min(n_samples, n_features)
         self._validate_n_components(self.n_components, n_samples, n_features)
 
-        policy = self._get_policy(queue, X)
         # TODO: investigate why np.ndarray with OWNDATA=FALSE flag
         # fails to be converted to oneDAL table
         if isinstance(X, np.ndarray) and not X.flags["OWNDATA"]:
@@ -154,9 +172,7 @@ class PCA(BasePCA):
 
         X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
-        result = self._get_backend(
-            "decomposition", "dim_reduction", "train", policy, params, X
-        )
+        result = self.train(params, X)
 
         self.mean_ = from_table(result.means).ravel()
         self.variances_ = from_table(result.variances)
@@ -169,10 +185,6 @@ class PCA(BasePCA):
         self.n_samples_ = n_samples
         self.n_features_ = n_features
 
-        U = None
-        S = self.singular_values_
-        Vt = self.components_
-
         n_components = self._resolve_n_components_for_result(X.shape)
         self.n_components_ = n_components
         self.noise_variance_ = self._compute_noise_variance(n_components, n_sf_min)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/decomposition/tests/test_incremental_pca.py

@@ -40,7 +40,7 @@ def test_on_gold_data(queue, is_deterministic, whiten, num_blocks, dtype):
 
     result = incpca.finalize_fit()
 
-    transformed_data = incpca.predict(X, queue=queue)
+    transformed_data = incpca.transform(X, queue=queue)
 
     expected_n_components_ = 2
     expected_components_ = np.array([[0.83849224, 0.54491354], [-0.54491354, 0.83849224]])
@@ -128,7 +128,7 @@ def test_on_random_data(
 
     incpca.finalize_fit()
 
-    transformed_data = incpca.predict(X, queue=queue)
+    transformed_data = incpca.transform(X, queue=queue)
     tol = 3e-3 if transformed_data.dtype == np.float32 else 2e-6
 
     n_components = incpca.n_components_

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.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()