scikit-learn-intelex 2025.1.0__py311-none-manylinux_2_28_x86_64.whl

onedal/cluster/tests/test_dbscan.py

@@ -0,0 +1,125 @@
+# ===============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from sklearn.cluster import DBSCAN as DBSCAN_SKLEARN
+from sklearn.cluster.tests.common import generate_clustered_data
+
+from onedal.cluster import DBSCAN as ONEDAL_DBSCAN
+from onedal.tests.utils._device_selection import get_queues
+
+
+def generate_data(
+    low: int, high: int, samples_number: int, sample_dimension: tuple
+) -> tuple:
+    generator = np.random.RandomState()
+    table_size = (samples_number, sample_dimension)
+    return generator.uniform(low=low, high=high, size=table_size), generator.uniform(
+        size=samples_number
+    )
+
+
+def check_labels_equals(left_labels: np.ndarray, right_labels: np.ndarray) -> bool:
+    if left_labels.shape != right_labels.shape:
+        raise Exception("Shapes not equal")
+    if len(left_labels.shape) != 1:
+        raise Exception("Shapes size not equals 1")
+    if len(set(left_labels)) != len(set(right_labels)):
+        raise Exception("Cluster counts not equal")
+    dict_checker = {}
+    for index_sample in range(left_labels.shape[0]):
+        if left_labels[index_sample] not in dict_checker:
+            dict_checker[left_labels[index_sample]] = right_labels[index_sample]
+        elif dict_checker[left_labels[index_sample]] != right_labels[index_sample]:
+            raise Exception("Wrong clustering")
+    return True
+
+
+def _test_dbscan_big_data_numpy_gen(
+    queue,
+    eps: float,
+    min_samples: int,
+    metric: str,
+    use_weights: bool,
+    low=-100.0,
+    high=100.0,
+    samples_number=1000,
+    sample_dimension=4,
+):
+    data, weights = generate_data(
+        low=low,
+        high=high,
+        samples_number=samples_number,
+        sample_dimension=sample_dimension,
+    )
+    if use_weights is False:
+        weights = None
+    initialized_daal_dbscan = ONEDAL_DBSCAN(
+        eps=eps, min_samples=min_samples, metric=metric
+    ).fit(X=data, sample_weight=weights, queue=queue)
+    initialized_sklearn_dbscan = DBSCAN_SKLEARN(
+        metric=metric, eps=eps, min_samples=min_samples
+    ).fit(X=data, sample_weight=weights)
+    check_labels_equals(
+        initialized_daal_dbscan.labels_, initialized_sklearn_dbscan.labels_
+    )
+
+
+@pytest.mark.parametrize(
+    "metric",
+    [
+        "euclidean",
+    ],
+)
+@pytest.mark.parametrize("use_weights", [True, False])
+@pytest.mark.parametrize("queue", get_queues())
+def test_dbscan_big_data_numpy_gen(queue, metric, use_weights: bool):
+    eps = 35.0
+    min_samples = 6
+    _test_dbscan_big_data_numpy_gen(
+        queue, eps=eps, min_samples=min_samples, metric=metric, use_weights=use_weights
+    )
+
+
+def _test_across_grid_parameter_numpy_gen(queue, metric, use_weights: bool):
+    eps_begin = 0.05
+    eps_end = 0.5
+    eps_step = 0.05
+    min_samples_begin = 5
+    min_samples_end = 15
+    min_samples_step = 1
+    for eps in np.arange(eps_begin, eps_end, eps_step):
+        for min_samples in range(min_samples_begin, min_samples_end, min_samples_step):
+            _test_dbscan_big_data_numpy_gen(
+                queue,
+                eps=eps,
+                min_samples=min_samples,
+                metric=metric,
+                use_weights=use_weights,
+            )
+
+
+@pytest.mark.parametrize(
+    "metric",
+    [
+        "euclidean",
+    ],
+)
+@pytest.mark.parametrize("use_weights", [True, False])
+@pytest.mark.parametrize("queue", get_queues())
+def test_across_grid_parameter_numpy_gen(queue, metric, use_weights: bool):
+    _test_across_grid_parameter_numpy_gen(queue, metric=metric, use_weights=use_weights)

onedal/cluster/tests/test_kmeans.py

@@ -0,0 +1,88 @@
+# ==============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+    from sklearn.cluster import kmeans_plusplus as init_external
+    from sklearn.neighbors import NearestNeighbors
+
+    from onedal.cluster import KMeans
+    from onedal.cluster import kmeans_plusplus as init_internal
+    from onedal.tests.utils._device_selection import get_queues
+
+    def generate_dataset(n_dim, n_cluster, n_points=None, seed=777, dtype=np.float32):
+        # We need some reference value of points for each cluster
+        n_points = (n_dim * n_cluster) if n_points is None else n_points
+
+        # Creating generator and generating cluster points
+        gen = np.random.Generator(np.random.MT19937(seed))
+        cs = gen.uniform(low=-1.0, high=+1.0, size=(n_cluster, n_dim))
+
+        # Finding variances for each cluster using 3 sigma criteria
+        # It ensures that point is in the Voronoi cell of cluster
+        nn = NearestNeighbors(n_neighbors=2)
+        d, i = nn.fit(cs).kneighbors(cs)
+        assert_array_equal(i[:, 0], np.arange(n_cluster))
+        vs = d[:, 1] / 3
+
+        # Generating dataset
+        def gen_one(c):
+            params = {"loc": cs[c, :], "scale": vs[c], "size": (n_points, n_dim)}
+            return gen.normal(**params)
+
+        data = [gen_one(c) for c in range(n_cluster)]
+        data = np.concatenate(data, axis=0)
+        gen.shuffle(data, axis=0)
+
+        data = data.astype(dtype)
+
+        return (cs, vs, data)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_dim", [3, 4, 17, 24])
+    @pytest.mark.parametrize("n_cluster", [9, 11, 32])
+    @pytest.mark.parametrize("pipeline", ["implicit", "external", "internal"])
+    def test_generated_dataset(queue, dtype, n_dim, n_cluster, pipeline):
+        seed = 777 * n_dim * n_cluster
+        cs, vs, X = generate_dataset(n_dim, n_cluster, seed=seed, dtype=dtype)
+
+        if pipeline == "external":
+            init_data, _ = init_external(X, n_cluster)
+            m = KMeans(n_cluster, init=init_data, max_iter=5)
+        elif pipeline == "internal":
+            init_data, _ = init_internal(X, n_cluster, queue=queue)
+            m = KMeans(n_cluster, init=init_data, max_iter=5)
+        else:
+            m = KMeans(n_cluster, init="k-means++", max_iter=5)
+
+        m.fit(X, queue=queue)
+
+        rs_centroids = m.cluster_centers_
+        nn = NearestNeighbors(n_neighbors=1)
+        d, i = nn.fit(rs_centroids).kneighbors(cs)
+        # We have applied 3 sigma rule once
+        desired_accuracy = int(0.9973 * n_cluster)
+        correctness = d.reshape(-1) <= (vs * 3)
+        exp_accuracy = np.count_nonzero(correctness)
+
+        # TODO: investigate accuracy with kmeans++ init and remove - 1
+        assert desired_accuracy - 1 <= exp_accuracy

onedal/cluster/tests/test_kmeans_init.py

@@ -0,0 +1,93 @@
+# ===============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+    from sklearn.datasets import load_breast_cancer
+    from sklearn.metrics import davies_bouldin_score
+
+    from onedal.cluster import KMeans, kmeans_plusplus
+    from onedal.tests.utils._device_selection import get_queues
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_cluster", [2, 5, 11, 128])
+    def test_breast_cancer(queue, dtype, n_cluster):
+        X, _ = load_breast_cancer(return_X_y=True)
+        X = np.asarray(X).astype(dtype=dtype)
+        init_data, _ = kmeans_plusplus(X, n_cluster, random_state=777, queue=queue)
+        m = KMeans(n_cluster, init=init_data, max_iter=1)
+        res = davies_bouldin_score(X, m.fit(X).predict(X))
+        thr = 0.45 if n_cluster < 20 else 0.55
+        assert res > thr
+
+    from sklearn.neighbors import NearestNeighbors
+
+    def generate_dataset(n_dim, n_cluster, n_points=None, seed=777, dtype=np.float32):
+        # We need some reference value of points for each cluster
+        n_points = (n_dim * n_cluster) if n_points is None else n_points
+
+        # Creating generator and generating cluster points
+        gen = np.random.Generator(np.random.MT19937(seed))
+        cs = gen.uniform(low=-1.0, high=+1.0, size=(n_cluster, n_dim))
+
+        # Finding variances for each cluster using 3 sigma criteria
+        # It ensures that point is in the Voronoi cell of cluster
+        nn = NearestNeighbors(n_neighbors=2)
+        d, i = nn.fit(cs).kneighbors(cs)
+        assert_array_equal(i[:, 0], np.arange(n_cluster))
+        vs = d[:, 1] / 3
+
+        # Generating dataset
+        def gen_one(c):
+            params = {"loc": cs[c, :], "scale": vs[c], "size": (n_points, n_dim)}
+            return gen.normal(**params)
+
+        data = [gen_one(c) for c in range(n_cluster)]
+        data = np.concatenate(data, axis=0)
+        gen.shuffle(data, axis=0)
+
+        data = data.astype(dtype)
+
+        return (cs, vs, data)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_dim", [3, 12, 17])
+    @pytest.mark.parametrize("n_cluster", [2, 15, 61])
+    def test_generated_dataset(queue, dtype, n_dim, n_cluster):
+        seed = 777 * n_dim * n_cluster
+        cs, vs, X = generate_dataset(n_dim, n_cluster, seed=seed, dtype=dtype)
+
+        init_data, _ = kmeans_plusplus(X, n_cluster, random_state=seed, queue=queue)
+        m = KMeans(n_cluster, init=init_data, max_iter=3, algorithm="lloyd").fit(X)
+
+        rs_centroids = m.cluster_centers_
+        nn = NearestNeighbors(n_neighbors=1)
+        d, i = nn.fit(rs_centroids).kneighbors(cs)
+        # We have applied 2 sigma rule once
+        desired_accuracy = int(0.9973 * n_cluster)
+        if d.dtype == np.float64:
+            desired_accuracy = desired_accuracy - 1
+        correctness = d.reshape(-1) <= (vs * 3)
+        exp_accuracy = np.count_nonzero(correctness)
+
+        assert desired_accuracy <= exp_accuracy

onedal/common/_base.py

@@ -0,0 +1,38 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from abc import ABC
+
+from onedal import _backend
+
+from ._policy import _get_policy
+
+
+def _get_backend(backend, module, submodule=None, method=None, *args, **kwargs):
+    result = getattr(backend, module)
+    if submodule:
+        result = getattr(result, submodule)
+    if method:
+        return getattr(result, method)(*args, **kwargs)
+    return result
+
+
+class BaseEstimator(ABC):
+    def _get_backend(self, module, submodule=None, method=None, *args, **kwargs):
+        return _get_backend(_backend, module, submodule, method, *args, **kwargs)
+
+    def _get_policy(self, queue, *data):
+        return _get_policy(queue, *data)

onedal/common/_estimator_checks.py

@@ -0,0 +1,47 @@
+# ===============================================================================
+# Copyright 2022 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+
+def _check_is_fitted(estimator, attributes=None, *, msg=None):
+    if msg is None:
+        msg = (
+            "This %(name)s instance is not fitted yet. Call 'fit' with "
+            "appropriate arguments before using this estimator."
+        )
+
+    if not (
+        hasattr(estimator, "fit")
+        or (hasattr(estimator, "partial_fit") and hasattr(estimator, "finalize_fit"))
+    ):
+        raise TypeError("%s is not an estimator instance." % (estimator))
+
+    if attributes is not None:
+        if not isinstance(attributes, (list, tuple)):
+            attributes = [attributes]
+        attrs = all([hasattr(estimator, attr) for attr in attributes])
+    else:
+        attrs = [v for v in vars(estimator) if v.endswith("_") and not v.startswith("__")]
+
+    if not attrs:
+        raise AttributeError(msg % {"name": type(estimator).__name__})
+
+
+def _is_classifier(estimator):
+    return getattr(estimator, "_estimator_type", None) == "classifier"
+
+
+def _is_regressor(estimator):
+    return getattr(estimator, "_estimator_type", None) == "regressor"

onedal/common/_mixin.py

@@ -0,0 +1,62 @@
+# ==============================================================================
+# Copyright 2021 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+class ClusterMixin:
+    _estimator_type = "clusterer"
+
+    def fit_predict(self, X, y=None, queue=None, **kwargs):
+        self.fit(X, queue=queue, **kwargs)
+        return self.labels_
+
+    def _more_tags(self):
+        return {"preserves_dtype": []}
+
+
+class ClassifierMixin:
+    _estimator_type = "classifier"
+
+    def score(self, X, y, sample_weight=None, queue=None):
+        from sklearn.metrics import accuracy_score
+
+        return accuracy_score(
+            y, self.predict(X, queue=queue), sample_weight=sample_weight
+        )
+
+    def _more_tags(self):
+        return {"requires_y": True}
+
+
+class RegressorMixin:
+    _estimator_type = "regressor"
+
+    def score(self, X, y, sample_weight=None, queue=None):
+        from sklearn.metrics import r2_score
+
+        return r2_score(y, self.predict(X, queue=queue), sample_weight=sample_weight)
+
+    def _more_tags(self):
+        return {"requires_y": True}
+
+
+class TransformerMixin:
+    _estimator_type = "transformer"
+
+    def fit_transform(self, X, y=None, queue=None, **fit_params):
+        if y is None:
+            return self.fit(X, queue=queue, **fit_params).transform(X, queue=queue)
+        else:
+            return self.fit(X, y, queue=queue, **fit_params).transform(X, queue=queue)

onedal/common/_policy.py

@@ -0,0 +1,59 @@
+# ==============================================================================
+# Copyright 2021 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import sys
+
+from onedal import _backend, _is_dpc_backend
+
+
+def _get_policy(queue, *data):
+    data_queue = _get_queue(*data)
+    if _is_dpc_backend:
+        if queue is None:
+            if data_queue is None:
+                return _HostInteropPolicy()
+            return _DataParallelInteropPolicy(data_queue)
+        return _DataParallelInteropPolicy(queue)
+    else:
+        if not (data_queue is None and queue is None):
+            raise RuntimeError(
+                "Operation using the requested SYCL queue requires the DPC backend"
+            )
+        return _HostInteropPolicy()
+
+
+def _get_queue(*data):
+    if len(data) > 0 and hasattr(data[0], "__sycl_usm_array_interface__"):
+        # Assume that all data reside on the same device
+        return data[0].__sycl_usm_array_interface__["syclobj"]
+    return None
+
+
+class _HostInteropPolicy(_backend.host_policy):
+    def __init__(self):
+        super().__init__()
+
+
+if _is_dpc_backend:
+    from onedal._device_offload import DummySyclQueue
+
+    class _DataParallelInteropPolicy(_backend.data_parallel_policy):
+        def __init__(self, queue):
+            self._queue = queue
+            if isinstance(queue, DummySyclQueue):
+                super().__init__(self._queue.sycl_device.get_filter_string())
+                return
+            super().__init__(self._queue)

onedal/common/_spmd_policy.py

@@ -0,0 +1,30 @@
+# ==============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from onedal import _is_spmd_backend
+
+if _is_spmd_backend:
+    from onedal import _spmd_backend
+
+    class _SPMDDataParallelInteropPolicy(_spmd_backend.spmd_data_parallel_policy):
+        def __init__(self, queue):
+            self._queue = queue
+            super().__init__(self._queue)
+
+    def _get_spmd_policy(queue):
+        # TODO:
+        # cases when queue is None
+        return _SPMDDataParallelInteropPolicy(queue)

onedal/common/hyperparameters.py

@@ -0,0 +1,125 @@
+# ==============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import logging
+from typing import Any, Dict, Tuple
+from warnings import warn
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal import _backend
+
+if not daal_check_version((2024, "P", 0)):
+    warn("Hyperparameters are supported in oneDAL starting from 2024.0.0 version.")
+    hyperparameters_map = {}
+else:
+    _hparams_reserved_words = [
+        "algorithm",
+        "op",
+        "setters",
+        "getters",
+        "backend",
+        "is_default",
+        "to_dict",
+    ]
+
+    class HyperParameters:
+        """Class for simplified interaction with oneDAL hyperparameters.
+        Overrides `__getattribute__` and `__setattr__` to utilize getters and setters
+        of hyperparameter class from onedal backend.
+        """
+
+        def __init__(self, algorithm, op, setters, getters, backend):
+            self.algorithm = algorithm
+            self.op = op
+            self.setters = setters
+            self.getters = getters
+            self.backend = backend
+            self.is_default = True
+
+        def __getattribute__(self, __name):
+            if __name in _hparams_reserved_words:
+                if __name == "backend":
+                    # `backend` attribute accessed only for oneDAL kernel calls
+                    logging.getLogger("sklearnex").debug(
+                        "Using next hyperparameters for "
+                        f"'{self.algorithm}.{self.op}': {self.to_dict()}"
+                    )
+                return super().__getattribute__(__name)
+            elif __name in self.getters.keys():
+                return self.getters[__name]()
+            try:
+                # try to return attribute from base class
+                # required to read builtin attributes like __class__, __doc__, etc.
+                # which are used in debuggers
+                return super().__getattribute__(__name)
+            except AttributeError:
+                # raise an AttributeError with a hyperparameter-specific message
+                # for easier debugging
+                raise AttributeError(
+                    f"Unknown attribute '{__name}' in "
+                    f"'{self.algorithm}.{self.op}' hyperparameters"
+                )
+
+        def __setattr__(self, __name, __value):
+            if __name in _hparams_reserved_words:
+                super().__setattr__(__name, __value)
+            elif __name in self.setters.keys():
+                self.is_default = False
+                self.setters[__name](__value)
+            else:
+                raise ValueError(
+                    f"Unknown attribute '{__name}' in "
+                    f"'{self.algorithm}.{self.op}' hyperparameters"
+                )
+
+        def to_dict(self):
+            return {name: getter() for name, getter in self.getters.items()}
+
+    def get_methods_with_prefix(obj, prefix):
+        return {
+            method.replace(prefix, ""): getattr(obj, method)
+            for method in filter(lambda f: f.startswith(prefix), dir(obj))
+        }
+
+    hyperparameters_backend: Dict[Tuple[str, str], Any] = {
+        (
+            "linear_regression",
+            "train",
+        ): _backend.linear_model.regression.train_hyperparameters(),
+        ("covariance", "compute"): _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_map = {}
+
+    for (algorithm, op), hyperparameters in hyperparameters_backend.items():
+        setters = get_methods_with_prefix(hyperparameters, "set_")
+        getters = get_methods_with_prefix(hyperparameters, "get_")
+
+        if set(setters.keys()) != set(getters.keys()):
+            raise ValueError(
+                f"Setters and getters in '{algorithm}.{op}' "
+                "hyperparameters wrapper do not correspond."
+            )
+
+        hyperparameters_map[(algorithm, op)] = HyperParameters(
+            algorithm, op, setters, getters, hyperparameters
+        )
+
+
+def get_hyperparameters(algorithm, op):
+    return hyperparameters_map.get((algorithm, op), None)