scikit-learn-intelex 2025.7.0__py312-none-win_amd64.whl → 2025.8.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/_device_offload.py

@@ -17,20 +17,18 @@
 import inspect
 import logging
 from functools import wraps
+from operator import xor
 
 import numpy as np
 from sklearn import get_config
 
-from onedal import _default_backend as backend
-
 from ._config import _get_config
-from .datatypes import copy_to_dpnp, copy_to_usm, usm_to_numpy
+from .datatypes import copy_to_dpnp, copy_to_usm, dlpack_to_numpy
 from .utils import _sycl_queue_manager as QM
-from .utils._array_api import _asarray, _is_numpy_namespace
+from .utils._array_api import _asarray, _get_sycl_namespace, _is_numpy_namespace
 from .utils._third_party import is_dpnp_ndarray
 
 logger = logging.getLogger("sklearnex")
-cpu_dlpack_device = (backend.kDLCPU, 0)
 
 
 def supports_queue(func):
@@ -65,44 +63,23 @@ def supports_queue(func):
 
 
 def _transfer_to_host(*data):
-    has_usm_data, has_host_data = False, False
+    has_usm_data = None
 
     host_data = []
     for item in data:
-        if usm_iface := getattr(item, "__sycl_usm_array_interface__", None):
-            item = usm_to_numpy(item, usm_iface)
-            has_usm_data = True
-        elif not isinstance(item, np.ndarray) and (
-            device := getattr(item, "__dlpack_device__", None)
-        ):
-            # check dlpack data location.
-            if device() != cpu_dlpack_device:
-                if hasattr(item, "to_device"):
-                    # use of the "cpu" string as device not officially part of
-                    # the array api standard but widely supported
-                    item = item.to_device("cpu")
-                elif hasattr(item, "to"):
-                    # pytorch-specific fix as it is not array api compliant
-                    item = item.to("cpu")
-                else:
-                    raise TypeError(f"cannot move {type(item)} to cpu")
-
-            # convert to numpy
-            if hasattr(item, "__array__"):
-                # `copy`` param for the `asarray`` is not set.
-                # The object is copied only if needed
-                item = np.asarray(item)
-            else:
-                # requires numpy 1.23
-                item = np.from_dlpack(item)
-            has_host_data = True
-        else:
-            has_host_data = True
-
-        mismatch_host_item = usm_iface is None and item is not None and has_usm_data
-        mismatch_usm_item = usm_iface is not None and has_host_data
-
-        if mismatch_host_item or mismatch_usm_item:
+        if item is None:
+            host_data.append(item)
+            continue
+
+        if usm_iface := hasattr(item, "__sycl_usm_array_interface__"):
+            xp = item.__array_namespace__()
+            item = xp.asnumpy(item)
+            has_usm_data = has_usm_data or has_usm_data is None
+        elif not isinstance(item, np.ndarray) and (hasattr(item, "__dlpack_device__")):
+            item = dlpack_to_numpy(item)
+
+        # set has_usm_data to boolean and use xor to see if they don't match
+        if xor((has_usm_data := bool(has_usm_data)), usm_iface):
             raise RuntimeError("Input data shall be located on single target device")
 
         host_data.append(item)
@@ -195,3 +172,27 @@ def support_input_format(func):
         return result
 
     return wrapper_impl
+
+
+def support_sycl_format(func):
+    # This wrapper enables scikit-learn functions and methods to work with
+    # all sycl data frameworks as they no longer support numpy implicit
+    # conversion and must be manually converted. This is only necessary
+    # when array API is supported but not active.
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if (
+            not get_config().get("array_api_dispatch", False)
+            and _get_sycl_namespace(*args)[2]
+        ):
+            with QM.manage_global_queue(kwargs.get("queue"), *args):
+                if inspect.isfunction(func) and "." in func.__qualname__:
+                    self, (args, kwargs) = args[0], _get_host_inputs(*args[1:], **kwargs)
+                    return func(self, *args, **kwargs)
+                else:
+                    args, kwargs = _get_host_inputs(*args, **kwargs)
+                    return func(*args, **kwargs)
+        return func(*args, **kwargs)
+
+    return wrapper

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/basic_statistics/basic_statistics.py

@@ -14,60 +14,13 @@
 # limitations under the License.
 # ==============================================================================
 
-from abc import ABCMeta, abstractmethod
-
-import numpy as np
-
-from onedal._device_offload import supports_queue
-
-from .._config import _get_config
+from .._device_offload import supports_queue
 from ..common._backend import bind_default_backend
 from ..datatypes import from_table, to_table
-from ..utils.validation import _check_array, _is_csr
-
-
-class BaseBasicStatistics(metaclass=ABCMeta):
-    @abstractmethod
-    def __init__(self, result_options, algorithm):
-        self.options = result_options
-        self.algorithm = algorithm
-
-    @bind_default_backend("basic_statistics")
-    def compute(self, params, data_table, weights_table): ...
-
-    @staticmethod
-    def get_all_result_options():
-        return [
-            "min",
-            "max",
-            "sum",
-            "mean",
-            "variance",
-            "variation",
-            "sum_squares",
-            "standard_deviation",
-            "sum_squares_centered",
-            "second_order_raw_moment",
-        ]
-
-    def _get_result_options(self, options):
-        if options == "all":
-            options = self.get_all_result_options()
-        if isinstance(options, list):
-            options = "|".join(options)
-        assert isinstance(options, str)
-        return options
-
-    def _get_onedal_params(self, is_csr, dtype=np.float32):
-        options = self._get_result_options(self.options)
-        return {
-            "fptype": dtype,
-            "method": "sparse" if is_csr else self.algorithm,
-            "result_option": options,
-        }
+from ..utils.validation import _is_csr
 
 
-class BasicStatistics(BaseBasicStatistics):
+class BasicStatistics:
     """Low order moments oneDAL estimator.
 
     Calculate basic statistics for data.
@@ -118,15 +71,52 @@ class BasicStatistics(BaseBasicStatistics):
     """
 
     def __init__(self, result_options="all", algorithm="by_default"):
-        super().__init__(result_options, algorithm)
+        self.options = result_options
+        self.algorithm = algorithm
+
+    @bind_default_backend("basic_statistics")
+    def compute(self, params, data_table, weights_table): ...
+
+    @staticmethod
+    def get_all_result_options():
+        return [
+            "min",
+            "max",
+            "sum",
+            "mean",
+            "variance",
+            "variation",
+            "sum_squares",
+            "standard_deviation",
+            "sum_squares_centered",
+            "second_order_raw_moment",
+        ]
+
+    @property
+    def options(self):
+        if self._options == ["all"]:
+            return self.get_all_result_options()
+        return self._options
+
+    @options.setter
+    def options(self, opts):
+        # options always to be an iterable
+        self._options = opts.split("|") if isinstance(opts, str) else opts
+
+    def _get_onedal_params(self, is_csr, dtype=None):
+        return {
+            "fptype": dtype,
+            "method": "sparse" if is_csr else self.algorithm,
+            "result_option": "|".join(self.options),
+        }
 
     @supports_queue
-    def fit(self, data, sample_weight=None, queue=None):
+    def fit(self, X, sample_weight=None, queue=None):
         """Generate statistics.
 
         Parameters
         ----------
-        data : array-like of shape (n_samples, n_features)
+        X : array-like of shape (n_samples, n_features)
             Training data batch, where `n_samples` is the number of samples
             in the batch, and `n_features` is the number of features.
 
@@ -143,33 +133,19 @@ class BasicStatistics(BaseBasicStatistics):
             Returns the instance itself.
         """
 
-        is_csr = _is_csr(data)
-
-        use_raw_input = _get_config().get("use_raw_input", False) is True
-        if not use_raw_input:
-            if data is not None and not is_csr:
-                data = _check_array(data, ensure_2d=False)
-            if sample_weight is not None:
-                sample_weight = _check_array(sample_weight, ensure_2d=False)
+        is_csr = _is_csr(X)
 
-        is_single_dim = data.ndim == 1
+        is_single_dim = X.ndim == 1
+        X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
 
-        data_table, weights_table = to_table(data, sample_weight, queue=queue)
+        result = self._compute_raw(X_table, sample_weight_table, X_table.dtype, is_csr)
 
-        dtype = data_table.dtype
-        raw_result = self._compute_raw(data_table, weights_table, dtype, is_csr)
-        for opt, raw_value in raw_result.items():
-            value = from_table(raw_value).ravel()
-            if is_single_dim:
-                setattr(self, opt, value[0])
-            else:
-                setattr(self, opt, value)
+        for opt in self.options:
+            value = from_table(getattr(result, opt), like=X)[0, :]  # 2D table [1, n]
+            setattr(self, opt + "_", value[0] if is_single_dim else value)
 
         return self
 
-    def _compute_raw(self, data_table, weights_table, dtype=np.float32, is_csr=False):
+    def _compute_raw(self, data_table, weights_table, dtype=None, is_csr=False):
         params = self._get_onedal_params(is_csr, dtype)
-        result = self.compute(params, data_table, weights_table)
-        options = self._get_result_options(self.options).split("|")
-
-        return {opt: getattr(result, opt) for opt in options}
+        return self.compute(params, data_table, weights_table)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/basic_statistics/incremental_basic_statistics.py

@@ -13,21 +13,14 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
+from ..datatypes import from_table, return_type_constructor, to_table
+from ..utils import _sycl_queue_manager as QM
+from .basic_statistics import BasicStatistics
 
-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._array_api import _get_sycl_namespace
-from ..utils.validation import _check_array
-from .basic_statistics import BaseBasicStatistics
-
-
-class IncrementalBasicStatistics(BaseBasicStatistics):
+class IncrementalBasicStatistics(BasicStatistics):
     """Incremental oneDAL low order moments estimator.
 
     Calculate basic statistics for data split into batches.
@@ -37,6 +30,9 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
     result_options : str or list, default=str('all')
         List of statistics to compute.
 
+    algorithm : str, default=str('by_default')
+        Method for statistics computation.
+
     Attributes
     ----------
         min : ndarray of shape (n_features,)
@@ -74,8 +70,8 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
         Attributes are populated only for corresponding result options.
     """
 
-    def __init__(self, result_options="all"):
-        super().__init__(result_options, algorithm="by_default")
+    def __init__(self, result_options="all", algorithm="by_default"):
+        super().__init__(result_options, algorithm)
         self._reset()
         self._queue = None
 
@@ -90,6 +86,7 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
 
     def _reset(self):
         self._need_to_finalize = False
+        self._outtype = None
         self._queue = None
         # get the _partial_result pointer from backend
         self._partial_result = self.partial_compute_result()
@@ -105,7 +102,7 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
         return data
 
     @supports_queue
-    def partial_fit(self, X, weights=None, queue=None):
+    def partial_fit(self, X, sample_weight=None, queue=None):
         """Generate partial statistics from batch data in `_partial_result`.
 
         Parameters
@@ -114,7 +111,7 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
             Training data batch, where `n_samples` is the number of samples
             in the batch, and `n_features` is the number of features.
 
-        weights : array-like of shape (n_samples,), default=None
+        sample_weight : array-like of shape (n_samples,), default=None
             Individual weights for each sample.
 
         queue : SyclQueue or None, default=None
@@ -126,34 +123,18 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
         self : object
             Returns the instance itself.
         """
-        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
 
         self._queue = queue
+        if not self._outtype:
+            self._outtype = return_type_constructor(X)
 
-        if not use_raw_input:
-            X = _check_array(
-                X, dtype=[np.float64, np.float32], ensure_2d=False, force_all_finite=False
-            )
-            if weights is not None:
-                weights = _check_array(
-                    weights,
-                    dtype=[np.float64, np.float32],
-                    ensure_2d=False,
-                    force_all_finite=False,
-                )
+        X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
 
         if not hasattr(self, "_onedal_params"):
-            dtype = get_dtype(X)
-            self._onedal_params = self._get_onedal_params(False, dtype=dtype)
+            self._onedal_params = self._get_onedal_params(False, dtype=X.dtype)
 
-        X_table, weights_table = to_table(X, weights, queue=queue)
         self._partial_result = self.partial_compute(
-            self._onedal_params, self._partial_result, X_table, weights_table
+            self._onedal_params, self._partial_result, X_table, sample_weight_table
         )
 
         self._need_to_finalize = True
@@ -171,10 +152,14 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
             with QM.manage_global_queue(self._queue):
                 result = self.finalize_compute(self._onedal_params, self._partial_result)
 
-            options = self._get_result_options(self.options).split("|")
-            for opt in options:
-                setattr(self, opt, from_table(getattr(result, opt)).ravel())
+            for opt in self.options:
+                setattr(
+                    self,
+                    opt + "_",
+                    from_table(getattr(result, opt), like=self._outtype)[0, :],
+                )
 
+            self._outtype = None
             self._need_to_finalize = False
 
         return self

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/basic_statistics/tests/test_basic_statistics.py

@@ -19,7 +19,6 @@ import pytest
 from numpy.testing import assert_allclose
 from scipy import sparse as sp
 
-from daal4py.sklearn._utils import daal_check_version
 from onedal.basic_statistics import BasicStatistics
 from onedal.basic_statistics.tests.utils import options_and_tests
 from onedal.tests.utils._device_selection import get_queues
@@ -57,7 +56,7 @@ def test_single_option_on_random_data(
 
     result = basicstat.fit(data, sample_weight=weights, queue=queue)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr = function(weighted_data)
@@ -89,7 +88,7 @@ def test_multiple_options_on_random_data(queue, row_count, column_count, weighte
 
     result = basicstat.fit(data, sample_weight=weights, queue=queue)
 
-    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    res_mean, res_max, res_sum = result.mean_, result.max_, result.sum_
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr_mean, gtr_max, gtr_sum = (
@@ -136,7 +135,7 @@ def test_all_option_on_random_data(queue, row_count, column_count, weighted, dty
     for result_option in options_and_tests:
         function, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
-        res = getattr(result, result_option)
+        res = getattr(result, result_option + "_")
         if weighted:
             gtr = function(weighted_data)
         else:
@@ -168,7 +167,7 @@ def test_1d_input_on_random_data(queue, result_option, data_size, weighted, dtyp
 
     result = basicstat.fit(data, sample_weight=weights, queue=queue)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = weights * data
         gtr = function(weighted_data)
@@ -199,7 +198,7 @@ def test_basic_csr(queue, dtype):
     basicstat = BasicStatistics(result_options="mean")
     result = basicstat.fit(data, queue=queue)
 
-    res_mean = result.mean
+    res_mean = result.mean_
     gtr_mean = data.mean(axis=0)
     tol = 5e-6 if res_mean.dtype == np.float32 else 1e-9
     assert_allclose(gtr_mean, res_mean, rtol=tol)
@@ -232,7 +231,7 @@ def test_options_csr(queue, option, dtype):
     basicstat = BasicStatistics(result_options=result_option)
     result = basicstat.fit(data, queue=queue)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     func = getattr(data, function)
     gtr = func(axis=0)
     if type(gtr).__name__ != "ndarray":

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/basic_statistics/tests/test_incremental_basic_statistics.py

@@ -49,16 +49,16 @@ def test_multiple_options_on_gold_data(queue, weighted, dtype):
         expected_weighted_mean = np.array([0.25, 0.25])
         expected_weighted_min = np.array([0, 0])
         expected_weighted_max = np.array([0.5, 0.5])
-        assert_allclose(expected_weighted_mean, result.mean)
-        assert_allclose(expected_weighted_max, result.max)
-        assert_allclose(expected_weighted_min, result.min)
+        assert_allclose(expected_weighted_mean, result.mean_)
+        assert_allclose(expected_weighted_max, result.max_)
+        assert_allclose(expected_weighted_min, result.min_)
     else:
         expected_mean = np.array([0.5, 0.5])
         expected_min = np.array([0, 0])
         expected_max = np.array([1, 1])
-        assert_allclose(expected_mean, result.mean)
-        assert_allclose(expected_max, result.max)
-        assert_allclose(expected_min, result.min)
+        assert_allclose(expected_mean, result.mean_)
+        assert_allclose(expected_max, result.max_)
+        assert_allclose(expected_min, result.min_)
 
 
 @pytest.mark.parametrize("queue", get_queues())
@@ -91,7 +91,7 @@ def test_single_option_on_random_data(
             incbs.partial_fit(data_split[i], queue=queue)
     result = incbs.finalize_fit()
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr = function(weighted_data)
@@ -129,7 +129,7 @@ def test_multiple_options_on_random_data(
             incbs.partial_fit(data_split[i], queue=queue)
     result = incbs.finalize_fit()
 
-    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    res_mean, res_max, res_sum = result.mean_, result.max_, result.sum_
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr_mean, gtr_max, gtr_sum = (
@@ -183,7 +183,7 @@ def test_all_option_on_random_data(
     for result_option in options_and_tests:
         function, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
-        res = getattr(result, result_option)
+        res = getattr(result, result_option + "_")
         if weighted:
             gtr = function(weighted_data)
         else:
@@ -273,7 +273,7 @@ def test_incremental_estimator_pickle(queue, dtype):
     for result_option in options_and_tests:
         _, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
-        res = getattr(incbs, result_option)
-        res_loaded = getattr(incbs_loaded, result_option)
+        res = getattr(incbs, result_option + "_")
+        res_loaded = getattr(incbs_loaded, result_option + "_")
         tol = fp32tol if res.dtype == np.float32 else fp64tol
         assert_allclose(res, res_loaded, atol=tol)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/cluster/dbscan.py

@@ -16,15 +16,11 @@
 
 import numpy as np
 
-from daal4py.sklearn._utils import make2d
 from onedal._device_offload import supports_queue
 
-from .._config import _get_config
 from ..common._backend import bind_default_backend
 from ..common._mixin import ClusterMixin
 from ..datatypes import from_table, to_table
-from ..utils._array_api import _get_sycl_namespace
-from ..utils.validation import _check_array
 
 
 class DBSCAN(ClusterMixin):
@@ -64,35 +60,21 @@ class DBSCAN(ClusterMixin):
 
     @supports_queue
     def fit(self, X, y=None, sample_weight=None, queue=None):
-        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 = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
-            X = make2d(X)
-        elif sua_iface is not None:
-            queue = X.sycl_queue
-
         X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
 
         params = self._get_onedal_params(X_table.dtype)
         result = self.compute(params, X_table, sample_weight_table)
 
-        self.labels_ = from_table(result.responses, sycl_queue=queue).ravel()
+        # 2d table but only 1d of information
+        self.labels_ = from_table(result.responses, like=X)[:, 0]
         if (
             result.core_observation_indices is not None
-            and not result.core_observation_indices.kind == "empty"
+            and result.core_observation_indices.kind != "empty"
         ):
+            # 2d table to 1d
             self.core_sample_indices_ = from_table(
-                result.core_observation_indices,
-                sycl_queue=queue,
-            ).ravel()
+                result.core_observation_indices, like=X
+            )[:, 0]
         else:
-            # construct keyword arguments for different namespaces (dptcl takes sycl_queue)
-            kwargs = {"dtype": xp.int32}  # always the same
-            if xp is not np:
-                kwargs["sycl_queue"] = queue
-            self.core_sample_indices_ = xp.empty((0,), **kwargs)
-        self.components_ = xp.take(X, self.core_sample_indices_, axis=0)
-        self.n_features_in_ = X.shape[1]
+            self.core_sample_indices_ = None
         return self

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/cluster/kmeans.py

@@ -105,7 +105,7 @@ class _BaseKMeans(TransformerMixin, ClusterMixin, ABC):
         bs = self._get_basic_statistics_backend("variance")
 
         res = bs._compute_raw(X_table, dummy, dtype, is_csr)
-        mean_var = from_table(res["variance"]).mean()
+        mean_var = from_table(res.variance).mean()
 
         return mean_var * rtol
 

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/common/hyperparameters.py

@@ -15,7 +15,7 @@
 # ==============================================================================
 
 import logging
-from typing import Any, Dict, Tuple
+from typing import Callable, Dict, Tuple
 from warnings import warn
 
 from daal4py.sklearn._utils import daal_check_version
@@ -94,22 +94,26 @@ else:
             for method in filter(lambda f: f.startswith(prefix), dir(obj))
         }
 
-    hyperparameters_backend: Dict[Tuple[str, str], Any] = {
+    hyperparameters_backend: Dict[Tuple[str, str], Callable] = {
         (
             "linear_regression",
             "train",
-        ): backend.linear_model.regression.train_hyperparameters(),
-        ("covariance", "compute"): backend.covariance.compute_hyperparameters(),
+        ): lambda: backend.linear_model.regression.train_hyperparameters(),
+        ("covariance", "compute"): lambda: backend.covariance.compute_hyperparameters(),
     }
     if daal_check_version((2024, "P", 300)):
-        df_infer_hp = backend.decision_forest.infer_hyperparameters
-        hyperparameters_backend[("decision_forest", "infer")] = df_infer_hp()
+        hyperparameters_backend[("decision_forest", "infer")] = (
+            lambda: backend.decision_forest.infer_hyperparameters()
+        )
     if daal_check_version((2025, "P", 700)):
-        pca_train_hp = backend.decomposition.dim_reduction.train_hyperparameters
-        hyperparameters_backend[("pca", "train")] = pca_train_hp()
-    hyperparameters_map = {}
+        hyperparameters_backend[("pca", "train")] = (
+            lambda: backend.decomposition.dim_reduction.train_hyperparameters()
+        )
+
+    hyperparameters_map: Dict[Tuple[str, str], HyperParameters] = {}
 
-    for (algorithm, op), hyperparameters in hyperparameters_backend.items():
+    for (algorithm, op), hyperparameters_lambda in hyperparameters_backend.items():
+        hyperparameters = hyperparameters_lambda()
         setters = get_methods_with_prefix(hyperparameters, "set_")
         getters = get_methods_with_prefix(hyperparameters, "get_")
 
@@ -123,6 +127,22 @@ else:
             algorithm, op, setters, getters, hyperparameters
         )
 
+    def get_hyperparameters_backend(algorithm, op):
+        """Get hyperparameters for a specific algorithm and operation."""
+        if (algorithm, op) in hyperparameters_backend:
+            return hyperparameters_backend[(algorithm, op)]()
+        else:
+            raise ValueError(f"Hyperparameters for '{algorithm}.{op}' are not defined.")
 
-def get_hyperparameters(algorithm, op):
+
+def get_hyperparameters(algorithm: str, op: str) -> HyperParameters:
     return hyperparameters_map.get((algorithm, op), None)
+
+
+def reset_hyperparameters(algorithm: str, op: str) -> None:
+    new_hyperparameters_backend = get_hyperparameters_backend(algorithm, op)
+    new_setters = get_methods_with_prefix(new_hyperparameters_backend, "set_")
+    new_getters = get_methods_with_prefix(new_hyperparameters_backend, "get_")
+    hyperparameters_map[(algorithm, op)] = HyperParameters(
+        algorithm, op, new_setters, new_getters, new_hyperparameters_backend
+    )