scikit-learn-intelex 2024.5.0__py39-none-win_amd64.whl → 2024.6.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -85,6 +85,9 @@ class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
         self.n_jobs = n_jobs
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        if sklearn_check_version("1.0"):
+            X = self._validate_data(X, force_all_finite=False)
+
         onedal_params = {
             "eps": self.eps,
             "min_samples": self.min_samples,

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/cluster/tests/test_dbscan.py

@@ -18,16 +18,18 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
 
-# TODO:
-# adding this parameterized testing
-# somehow breaks other test with preview module patch:
-# sklearnex/tests/test_monkeypatch.py::test_preview_namespace.
-# @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-def test_sklearnex_import_dbscan():
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_dbscan(dataframe, queue):
     from sklearnex.cluster import DBSCAN
 
     X = np.array([[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]])
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     dbscan = DBSCAN(eps=3, min_samples=2).fit(X)
     assert "sklearnex" in dbscan.__module__
 

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/conftest.py

@@ -19,7 +19,8 @@ import logging
 
 import pytest
 
-from sklearnex import patch_sklearn, unpatch_sklearn
+from daal4py.sklearn._utils import sklearn_check_version
+from sklearnex import config_context, patch_sklearn, unpatch_sklearn
 
 
 def pytest_configure(config):
@@ -61,3 +62,12 @@ def with_sklearnex():
     patch_sklearn()
     yield
     unpatch_sklearn()
+
+
+@pytest.fixture
+def with_array_api():
+    if sklearn_check_version("1.2"):
+        with config_context(array_api_dispatch=True):
+            yield
+    else:
+        yield

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/decomposition/tests/test_pca.py

@@ -51,6 +51,8 @@ def test_sklearnex_import(dataframe, queue):
         assert hasattr(pca, "_onedal_estimator")
     else:
         assert "daal4py" in pca.__module__
+
+    tol = 1e-5 if _as_numpy(X_transformed).dtype == np.float32 else 1e-7
     assert_allclose([6.30061232, 0.54980396], _as_numpy(pca.singular_values_))
-    assert_allclose(X_transformed_expected, _as_numpy(X_transformed))
-    assert_allclose(X_transformed_expected, _as_numpy(X_fit_transformed))
+    assert_allclose(X_transformed_expected, _as_numpy(X_transformed), rtol=tol)
+    assert_allclose(X_transformed_expected, _as_numpy(X_fit_transformed), rtol=tol)

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -45,12 +45,14 @@ def get_patch_map_core(preview=False):
 
         if _is_new_patching_available():
             import sklearn.covariance as covariance_module
+            import sklearn.decomposition as decomposition_module
 
             # Preview classes for patching
             from .preview.cluster import KMeans as KMeans_sklearnex
             from .preview.covariance import (
                 EmpiricalCovariance as EmpiricalCovariance_sklearnex,
             )
+            from .preview.decomposition import IncrementalPCA as IncrementalPCA_sklearnex
 
             # Since the state of the lru_cache without preview cannot be
             # guaranteed to not have already enabled sklearnex algorithms
@@ -62,7 +64,7 @@ def get_patch_map_core(preview=False):
             sklearn_obj = mapping["kmeans"][0][1]
             mapping.pop("kmeans")
             mapping["kmeans"] = [
-                [(cluster_module, "kmeans", KMeans_sklearnex), sklearn_obj]
+                [(cluster_module, "KMeans", KMeans_sklearnex), sklearn_obj]
             ]
 
             # Covariance
@@ -76,6 +78,18 @@ def get_patch_map_core(preview=False):
                     None,
                 ]
             ]
+
+            # IncrementalPCA
+            mapping["incrementalpca"] = [
+                [
+                    (
+                        decomposition_module,
+                        "IncrementalPCA",
+                        IncrementalPCA_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
         return mapping
 
     from daal4py.sklearn.monkeypatch.dispatcher import _get_map_of_algorithms

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -29,7 +29,7 @@ from sklearn.ensemble._forest import ForestClassifier as sklearn_ForestClassifie
 from sklearn.ensemble._forest import ForestRegressor as sklearn_ForestRegressor
 from sklearn.ensemble._forest import _get_n_samples_bootstrap
 from sklearn.exceptions import DataConversionWarning
-from sklearn.metrics import accuracy_score
+from sklearn.metrics import accuracy_score, r2_score
 from sklearn.tree import (
     DecisionTreeClassifier,
     DecisionTreeRegressor,
@@ -38,7 +38,7 @@ from sklearn.tree import (
 )
 from sklearn.tree._tree import Tree
 from sklearn.utils import check_random_state, deprecated
-from sklearn.utils.validation import check_array, check_is_fitted
+from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import (
@@ -74,6 +74,7 @@ class BaseForest(ABC):
             accept_sparse=False,
             dtype=[np.float64, np.float32],
             force_all_finite=False,
+            ensure_2d=True,
         )
 
         if sample_weight is not None:
@@ -97,8 +98,6 @@ class BaseForest(ABC):
 
         y, expanded_class_weight = self._validate_y_class_weight(y)
 
-        self.n_features_in_ = X.shape[1]
-
         if expanded_class_weight is not None:
             if sample_weight is not None:
                 sample_weight = sample_weight * expanded_class_weight
@@ -114,7 +113,9 @@ class BaseForest(ABC):
             "min_samples_split": self.min_samples_split,
             "min_samples_leaf": self.min_samples_leaf,
             "min_weight_fraction_leaf": self.min_weight_fraction_leaf,
-            "max_features": self.max_features,
+            "max_features": self._to_absolute_max_features(
+                self.max_features, self.n_features_in_
+            ),
             "max_leaf_nodes": self.max_leaf_nodes,
             "min_impurity_decrease": self.min_impurity_decrease,
             "bootstrap": self.bootstrap,
@@ -174,6 +175,45 @@ class BaseForest(ABC):
         self._validate_estimator()
         return self
 
+    def _to_absolute_max_features(self, max_features, n_features):
+        if max_features is None:
+            return n_features
+        if isinstance(max_features, str):
+            if max_features == "auto":
+                if not sklearn_check_version("1.3"):
+                    if sklearn_check_version("1.1"):
+                        warnings.warn(
+                            "`max_features='auto'` has been deprecated in 1.1 "
+                            "and will be removed in 1.3. To keep the past behaviour, "
+                            "explicitly set `max_features=1.0` or remove this "
+                            "parameter as it is also the default value for "
+                            "RandomForestRegressors and ExtraTreesRegressors.",
+                            FutureWarning,
+                        )
+                    return (
+                        max(1, int(np.sqrt(n_features)))
+                        if isinstance(self, ForestClassifier)
+                        else n_features
+                    )
+            if max_features == "sqrt":
+                return max(1, int(np.sqrt(n_features)))
+            if max_features == "log2":
+                return max(1, int(np.log2(n_features)))
+            allowed_string_values = (
+                '"sqrt" or "log2"'
+                if sklearn_check_version("1.3")
+                else '"auto", "sqrt" or "log2"'
+            )
+            raise ValueError(
+                "Invalid value for max_features. Allowed string "
+                f"values are {allowed_string_values}."
+            )
+        if isinstance(max_features, (numbers.Integral, np.integer)):
+            return max_features
+        if max_features > 0.0:
+            return max(1, int(max_features * n_features))
+        return 0
+
     def _check_parameters(self):
         if isinstance(self.min_samples_leaf, numbers.Integral):
             if not 1 <= self.min_samples_leaf:
@@ -518,7 +558,7 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
             )
 
         if patching_status.get_status():
-            X, y = self._validate_data(
+            X, y = check_X_y(
                 X,
                 y,
                 multi_output=True,
@@ -738,6 +778,10 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
                         or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.1",
                     ),
+                    (
+                        not self.oob_score,
+                        "oob_scores using r2 or accuracy not implemented.",
+                    ),
                     (sample_weight is None, "sample_weight is not supported."),
                 ]
             )
@@ -780,24 +824,43 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
         check_is_fitted(self, "_onedal_estimator")
 
         if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
-
-        X = check_array(
-            X,
-            dtype=[np.float64, np.float32],
-            force_all_finite=False,
-        )  # Warning, order of dtype matters
+            X = self._validate_data(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                reset=False,
+                ensure_2d=True,
+            )
+        else:
+            X = check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+            )  # Warning, order of dtype matters
+            self._check_n_features(X, reset=False)
 
         res = self._onedal_estimator.predict(X, queue=queue)
         return np.take(self.classes_, res.ravel().astype(np.int64, casting="unsafe"))
 
     def _onedal_predict_proba(self, X, queue=None):
-        X = check_array(X, dtype=[np.float64, np.float32], force_all_finite=False)
         check_is_fitted(self, "_onedal_estimator")
 
-        self._check_n_features(X, reset=False)
         if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+            X = self._validate_data(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                reset=False,
+                ensure_2d=True,
+            )
+        else:
+            X = check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+            )  # Warning, order of dtype matters
+            self._check_n_features(X, reset=False)
+
         return self._onedal_estimator.predict_proba(X, queue=queue)
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
@@ -914,7 +977,7 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
             )
 
         if patching_status.get_status():
-            X, y = self._validate_data(
+            X, y = check_X_y(
                 X,
                 y,
                 multi_output=True,
@@ -996,7 +1059,7 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
                 ]
             )
 
-        elif method_name == "predict":
+        elif method_name in ["predict", "score"]:
             X = data[0]
 
             patching_status.and_conditions(
@@ -1046,11 +1109,12 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
                         or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.1",
                     ),
+                    (not self.oob_score, "oob_score value is not sklearn conformant."),
                     (sample_weight is None, "sample_weight is not supported."),
                 ]
             )
 
-        elif method_name == "predict":
+        elif method_name in ["predict", "score"]:
             X = data[0]
 
             patching_status.and_conditions(
@@ -1083,16 +1147,28 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
         return patching_status
 
     def _onedal_predict(self, X, queue=None):
-        X = check_array(
-            X, dtype=[np.float64, np.float32], force_all_finite=False
-        )  # Warning, order of dtype matters
         check_is_fitted(self, "_onedal_estimator")
 
         if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+            X = self._validate_data(
+                X,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+                reset=False,
+                ensure_2d=True,
+            )  # Warning, order of dtype matters
+        else:
+            X = check_array(
+                X, dtype=[np.float64, np.float32], force_all_finite=False
+            )  # Warning, order of dtype matters
 
         return self._onedal_estimator.predict(X, queue=queue)
 
+    def _onedal_score(self, X, y, sample_weight=None, queue=None):
+        return r2_score(
+            y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
+        )
+
     def fit(self, X, y, sample_weight=None):
         dispatch(
             self,
@@ -1119,8 +1195,23 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
             X,
         )
 
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": sklearn_ForestRegressor.score,
+            },
+            X,
+            y,
+            sample_weight=sample_weight,
+        )
+
     fit.__doc__ = sklearn_ForestRegressor.fit.__doc__
     predict.__doc__ = sklearn_ForestRegressor.predict.__doc__
+    score.__doc__ = sklearn_ForestRegressor.score.__doc__
 
 
 @control_n_jobs(decorated_methods=["fit", "predict", "predict_proba", "score"])

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/ensemble/tests/test_forest.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ===============================================================================
 
+import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 from sklearn.datasets import make_classification, make_regression
@@ -45,7 +46,10 @@ def test_sklearnex_import_rf_classifier(dataframe, queue):
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 
 
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+# TODO: fix RF regressor predict for the GPU sycl_queue.
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
+)
 def test_sklearnex_import_rf_regression(dataframe, queue):
     from sklearnex.ensemble import RandomForestRegressor
 
@@ -65,7 +69,10 @@ def test_sklearnex_import_rf_regression(dataframe, queue):
             assert_allclose([-6.839], pred, atol=1e-2)
 
 
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+# TODO: fix ET classifier predict for the GPU sycl_queue.
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
+)
 def test_sklearnex_import_et_classifier(dataframe, queue):
     from sklearnex.ensemble import ExtraTreesClassifier
 
@@ -86,7 +93,10 @@ def test_sklearnex_import_et_classifier(dataframe, queue):
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 
 
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+# TODO: fix ET regressor predict for the GPU sycl_queue.
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
+)
 def test_sklearnex_import_et_regression(dataframe, queue):
     from sklearnex.ensemble import ExtraTreesRegressor
 

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/glob/dispatcher.py

@@ -17,18 +17,32 @@
 
 def get_patch_str(name=None, verbose=True):
     return f"""try:
+    # TEMP. FIX: sklearnex.patch_sklearn imports sklearn beforehand
+    # when it didn't initialized _threadpool_controller required for
+    # pairwise distances dispatching during imports.
+    # Manually setting and deleting _threadpool_controller during patch fixes it.
+    import sklearn
+    from threadpoolctl import ThreadpoolController
+    sklearn._threadpool_controller = ThreadpoolController()
     from sklearnex import patch_sklearn
     patch_sklearn(name={str(name)}, verbose={str(verbose)})
-    del patch_sklearn
+    del patch_sklearn, sklearn._threadpool_controller
 except ImportError:
     pass"""
 
 
 def get_patch_str_re():
     return r"""\ntry:
+    \# TEMP. FIX: sklearnex.patch_sklearn imports sklearn beforehand
+    \# when it didn't initialized _threadpool_controller required for
+    \# pairwise distances dispatching during imports.
+    \# Manually setting and deleting _threadpool_controller during patch fixes it.
+    import sklearn
+    from threadpoolctl import ThreadpoolController
+    sklearn._threadpool_controller = ThreadpoolController\(\)
     from sklearnex import patch_sklearn
     patch_sklearn\(name=.*, verbose=.*\)
-    del patch_sklearn
+    del patch_sklearn, sklearn._threadpool_controller
 except ImportError:
     pass\n"""
 

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -20,6 +20,7 @@ import warnings
 import numpy as np
 from sklearn.base import BaseEstimator, MultiOutputMixin, RegressorMixin
 from sklearn.exceptions import NotFittedError
+from sklearn.metrics import r2_score
 from sklearn.utils import check_array, gen_batches
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
@@ -134,6 +135,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
                 X,
                 dtype=[np.float64, np.float32],
                 copy=self.copy_X,
+                reset=False,
             )
         else:
             X = check_array(
@@ -147,33 +149,42 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
             self._onedal_finalize_fit()
         return self._onedal_estimator.predict(X, queue)
 
-    def _onedal_partial_fit(self, X, y, queue=None):
+    def _onedal_score(self, X, y, sample_weight=None, queue=None):
+        return r2_score(
+            y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
+        )
+
+    def _onedal_partial_fit(self, X, y, check_input=True, queue=None):
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
         if sklearn_check_version("1.2"):
             self._validate_params()
 
-        if sklearn_check_version("1.0"):
-            X, y = self._validate_data(
-                X,
-                y,
-                dtype=[np.float64, np.float32],
-                reset=first_pass,
-                copy=self.copy_X,
-                multi_output=True,
-            )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                copy=self.copy_X,
-            )
-            y = check_array(
-                y,
-                dtype=[np.float64, np.float32],
-                copy=False,
-                ensure_2d=False,
-            )
+        if check_input:
+            if sklearn_check_version("1.0"):
+                X, y = self._validate_data(
+                    X,
+                    y,
+                    dtype=[np.float64, np.float32],
+                    reset=first_pass,
+                    copy=self.copy_X,
+                    multi_output=True,
+                    force_all_finite=False,
+                )
+            else:
+                X = check_array(
+                    X,
+                    dtype=[np.float64, np.float32],
+                    copy=self.copy_X,
+                    force_all_finite=False,
+                )
+                y = check_array(
+                    y,
+                    dtype=[np.float64, np.float32],
+                    copy=False,
+                    ensure_2d=False,
+                    force_all_finite=False,
+                )
 
         if first_pass:
             self.n_samples_seen_ = X.shape[0]
@@ -202,7 +213,12 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
 
         if sklearn_check_version("1.0"):
             X, y = self._validate_data(
-                X, y, dtype=[np.float64, np.float32], copy=self.copy_X, multi_output=True
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                copy=self.copy_X,
+                multi_output=True,
+                ensure_2d=True,
             )
         else:
             X = check_array(
@@ -234,7 +250,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
 
         for batch in gen_batches(n_samples, self.batch_size_):
             X_batch, y_batch = X[batch], y[batch]
-            self._onedal_partial_fit(X_batch, y_batch, queue=queue)
+            self._onedal_partial_fit(X_batch, y_batch, check_input=False, queue=queue)
 
         if sklearn_check_version("1.2"):
             self._validate_params()
@@ -288,7 +304,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
     coef_ = property(get_coef_, set_coef_)
     intercept_ = property(get_intercept_, set_intercept_)
 
-    def partial_fit(self, X, y):
+    def partial_fit(self, X, y, check_input=True):
         """
         Incremental fit linear model with X and y. All of X and y is
         processed as a single batch.
@@ -318,6 +334,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
             },
             X,
             y,
+            check_input=check_input,
         )
         return self
 
@@ -385,3 +402,63 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
             },
             X,
         )
+
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        """Return the coefficient of determination of the prediction.
+
+        The coefficient of determination :math:`R^2` is defined as
+        :math:`(1 - \\frac{u}{v})`, where :math:`u` is the residual
+        sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`
+        is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.
+        The best possible score is 1.0 and it can be negative (because the
+        model can be arbitrarily worse). A constant model that always predicts
+        the expected value of `y`, disregarding the input features, would get
+        a :math:`R^2` score of 0.0.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Test samples. For some estimators this may be a precomputed
+            kernel matrix or a list of generic objects instead with shape
+            ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``
+            is the number of samples used in the fitting for the estimator.
+
+        y : array-like of shape (n_samples,) or (n_samples, n_outputs)
+            True values for `X`.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights.
+
+        Returns
+        -------
+        score : float
+            :math:`R^2` of ``self.predict(X)`` w.r.t. `y`.
+
+        Notes
+        -----
+        The :math:`R^2` score used when calling ``score`` on a regressor uses
+        ``multioutput='uniform_average'`` from version 0.23 to keep consistent
+        with default value of :func:`~sklearn.metrics.r2_score`.
+        This influences the ``score`` method of all the multioutput
+        regressors (except for
+        :class:`~sklearn.multioutput.MultiOutputRegressor`).
+        """
+        if not hasattr(self, "coef_"):
+            msg = (
+                "This %(name)s instance is not fitted yet. Call 'fit' or 'partial_fit' "
+                "with appropriate arguments before using this estimator."
+            )
+            raise NotFittedError(msg % {"name": self.__class__.__name__})
+
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": None,
+            },
+            X,
+            y,
+            sample_weight=sample_weight,
+        )