scikit-learn-intelex 2024.7.0__py310-none-win_amd64.whl → 2025.0.0__py310-none-win_amd64.whl

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -0,0 +1,383 @@
+# ==============================================================================
+# 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 logging
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+
+    import numbers
+    import warnings
+
+    import numpy as np
+    from scipy.sparse import issparse
+    from sklearn.cluster import KMeans as sklearn_KMeans
+    from sklearn.utils._openmp_helpers import _openmp_effective_n_threads
+    from sklearn.utils.validation import (
+        _check_sample_weight,
+        _num_samples,
+        check_is_fitted,
+    )
+
+    from daal4py.sklearn._n_jobs_support import control_n_jobs
+    from daal4py.sklearn._utils import sklearn_check_version
+    from onedal.cluster import KMeans as onedal_KMeans
+    from onedal.utils import _is_csr
+
+    from .._device_offload import dispatch, wrap_output_data
+    from .._utils import PatchingConditionsChain
+
+    @control_n_jobs(decorated_methods=["fit", "predict", "transform", "fit_transform"])
+    class KMeans(sklearn_KMeans):
+        __doc__ = sklearn_KMeans.__doc__
+
+        if sklearn_check_version("1.2"):
+            _parameter_constraints: dict = {**sklearn_KMeans._parameter_constraints}
+
+        def __init__(
+            self,
+            n_clusters=8,
+            *,
+            init="k-means++",
+            n_init=(
+                "auto"
+                if sklearn_check_version("1.4")
+                else "warn" if sklearn_check_version("1.2") else 10
+            ),
+            max_iter=300,
+            tol=1e-4,
+            verbose=0,
+            random_state=None,
+            copy_x=True,
+            algorithm="lloyd" if sklearn_check_version("1.1") else "auto",
+        ):
+            super().__init__(
+                n_clusters=n_clusters,
+                init=init,
+                max_iter=max_iter,
+                tol=tol,
+                n_init=n_init,
+                verbose=verbose,
+                random_state=random_state,
+                copy_x=copy_x,
+                algorithm=algorithm,
+            )
+
+        def _initialize_onedal_estimator(self):
+            onedal_params = {
+                "n_clusters": self.n_clusters,
+                "init": self.init,
+                "max_iter": self.max_iter,
+                "tol": self.tol,
+                "n_init": self.n_init,
+                "verbose": self.verbose,
+                "random_state": self.random_state,
+            }
+
+            self._onedal_estimator = onedal_KMeans(**onedal_params)
+
+        def _onedal_fit_supported(self, method_name, X, y=None, sample_weight=None):
+            assert method_name == "fit"
+
+            class_name = self.__class__.__name__
+            patching_status = PatchingConditionsChain(f"sklearn.cluster.{class_name}.fit")
+
+            sample_count = _num_samples(X)
+            self._algorithm = self.algorithm
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+            correct_count = self.n_clusters < sample_count
+
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+
+            _acceptable_sample_weights = self._validate_sample_weight(sample_weight, X)
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd",
+                    ),
+                    (correct_count, "n_clusters is smaller than number of samples"),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Accepted options are None, constant, or equal weights.",
+                    ),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        def fit(self, X, y=None, sample_weight=None):
+            if sklearn_check_version("1.2"):
+                self._validate_params()
+
+            dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": sklearn_KMeans.fit,
+                },
+                X,
+                y,
+                sample_weight,
+            )
+
+            return self
+
+        def _onedal_fit(self, X, _, sample_weight, queue=None):
+            X = self._validate_data(
+                X,
+                accept_sparse="csr",
+                dtype=[np.float64, np.float32],
+                order="C",
+                copy=self.copy_x,
+                accept_large_sparse=False,
+            )
+
+            if sklearn_check_version("1.2"):
+                self._check_params_vs_input(X)
+            else:
+                self._check_params(X)
+
+            self._n_features_out = self.n_clusters
+
+            self._initialize_onedal_estimator()
+            self._n_threads = _openmp_effective_n_threads()
+            self._onedal_estimator.fit(X, queue=queue)
+
+            self._save_attributes()
+
+        def _validate_sample_weight(self, sample_weight, X):
+            if sample_weight is None:
+                return True
+            elif isinstance(sample_weight, numbers.Number):
+                return True
+            else:
+                sample_weight = _check_sample_weight(
+                    sample_weight,
+                    X,
+                    dtype=X.dtype if hasattr(X, "dtype") else None,
+                )
+                if np.all(sample_weight == sample_weight[0]):
+                    return True
+                else:
+                    return False
+
+        def _onedal_predict_supported(self, method_name, X, sample_weight=None):
+            class_name = self.__class__.__name__
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+            patching_status = PatchingConditionsChain(
+                f"sklearn.cluster.{class_name}.predict"
+            )
+
+            # algorithm "auto" has been deprecated since 1.1,
+            # algorithm "full" has been replaced by "lloyd"
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+
+            _acceptable_sample_weights = True
+            if not sklearn_check_version("1.5"):
+                _acceptable_sample_weights = self._validate_sample_weight(
+                    sample_weight, X
+                )
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd.",
+                    ),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Acceptable options are None, constant, or equal weights.",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        if sklearn_check_version("1.5"):
+
+            @wrap_output_data
+            def predict(self, X):
+                self._validate_params()
+
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": sklearn_KMeans.predict,
+                    },
+                    X,
+                )
+
+        else:
+
+            @wrap_output_data
+            def predict(
+                self,
+                X,
+                sample_weight="deprecated" if sklearn_check_version("1.3") else None,
+            ):
+                if sklearn_check_version("1.2"):
+                    self._validate_params()
+
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": sklearn_KMeans.predict,
+                    },
+                    X,
+                    sample_weight=sample_weight,
+                )
+
+        def _onedal_predict(self, X, sample_weight=None, queue=None):
+            check_is_fitted(self)
+
+            X = self._validate_data(
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not sklearn_check_version("1.5") and sklearn_check_version("1.3"):
+                if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                    sample_weight = None
+
+                if sample_weight is not None:
+                    warnings.warn(
+                        "'sample_weight' was deprecated in version 1.3 and "
+                        "will be removed in 1.5.",
+                        FutureWarning,
+                    )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.predict(X, queue=queue)
+
+        def _onedal_supported(self, method_name, *data):
+            if method_name == "fit":
+                return self._onedal_fit_supported(method_name, *data)
+            if method_name in ["predict", "score"]:
+                return self._onedal_predict_supported(method_name, *data)
+            raise RuntimeError(
+                f"Unknown method {method_name} in {self.__class__.__name__}"
+            )
+
+        _onedal_gpu_supported = _onedal_supported
+        _onedal_cpu_supported = _onedal_supported
+
+        @wrap_output_data
+        def fit_transform(self, X, y=None, sample_weight=None):
+            return self.fit(X, sample_weight=sample_weight)._transform(X)
+
+        @wrap_output_data
+        def transform(self, X):
+            check_is_fitted(self)
+
+            X = self._check_test_data(X)
+            return self._transform(X)
+
+        @wrap_output_data
+        def score(self, X, y=None, sample_weight=None):
+            return dispatch(
+                self,
+                "score",
+                {
+                    "onedal": self.__class__._onedal_score,
+                    "sklearn": sklearn_KMeans.score,
+                },
+                X,
+                y,
+                sample_weight=sample_weight,
+            )
+
+        def _onedal_score(self, X, y, sample_weight=None, queue=None):
+            check_is_fitted(self)
+
+            X = self._validate_data(
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not sklearn_check_version("1.5") and sklearn_check_version("1.3"):
+                if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                    sample_weight = None
+
+                if sample_weight is not None:
+                    warnings.warn(
+                        "'sample_weight' was deprecated in version 1.3 and "
+                        "will be removed in 1.5.",
+                        FutureWarning,
+                    )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.score(X, queue=queue)
+
+        def _save_attributes(self):
+            assert hasattr(self, "_onedal_estimator")
+            self.cluster_centers_ = self._onedal_estimator.cluster_centers_
+            self.labels_ = self._onedal_estimator.labels_
+            self.inertia_ = self._onedal_estimator.inertia_
+            self.n_iter_ = self._onedal_estimator.n_iter_
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+
+            self._n_init = self._onedal_estimator._n_init
+
+        fit.__doc__ = sklearn_KMeans.fit.__doc__
+        predict.__doc__ = sklearn_KMeans.predict.__doc__
+        transform.__doc__ = sklearn_KMeans.transform.__doc__
+        fit_transform.__doc__ = sklearn_KMeans.fit_transform.__doc__
+        score.__doc__ = sklearn_KMeans.score.__doc__
+
+else:
+    from daal4py.sklearn.cluster import KMeans
+
+    logging.warning(
+        "Sklearnex KMeans requires oneDAL version >= 2023.2, falling back to daal4py."
+    )

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/sklearnex/cluster/tests/test_kmeans.py

@@ -0,0 +1,153 @@
+# ===============================================================================
+# 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 numpy as np
+import pytest
+from numpy.testing import assert_allclose
+from scipy.sparse import csr_matrix
+from sklearn.datasets import make_blobs
+
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+    get_queues,
+)
+from sklearnex import config_context
+
+
+def generate_dense_dataset(n_samples, n_features, density, n_clusters):
+    np.random.seed(2024 + n_samples + n_features + n_clusters)
+    X, _ = make_blobs(
+        n_samples=n_samples,
+        n_features=n_features,
+        centers=n_clusters,
+        cluster_std=1.0,
+        random_state=42,
+    )
+    mask = np.random.binomial(1, density, (n_samples, n_features))
+    X = X * mask
+    return X
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_dense_data(dataframe, queue, algorithm, init):
+    if not sklearn_check_version("1.1") and algorithm == "lloyd":
+        pytest.skip("lloyd requires sklearn>=1.1.")
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_dense_df = _convert_to_dataframe(X_dense, sycl_queue=queue, target_df=dataframe)
+
+    kmeans_dense = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_dense_df)
+
+    if daal_check_version((2023, "P", 200)):
+        assert "sklearnex" in kmeans_dense.__module__
+    else:
+        assert "daal4py" in kmeans_dense.__module__
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_sparse_data(queue, algorithm, init):
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_sparse = csr_matrix(X_dense)
+
+    kmeans_sparse = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_sparse)
+
+    assert "sklearnex" in kmeans_sparse.__module__
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+def test_results_on_dense_gold_data(dataframe, queue, algorithm):
+    if not sklearn_check_version("1.1") and algorithm == "lloyd":
+        pytest.skip("lloyd requires sklearn>=1.1.")
+
+    from sklearnex.cluster import KMeans
+
+    X_train = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
+    X_test = np.array([[0, 0], [12, 3]])
+    X_train_df = _convert_to_dataframe(X_train, sycl_queue=queue, target_df=dataframe)
+    X_test_df = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+
+    kmeans = KMeans(n_clusters=2, random_state=0, algorithm=algorithm).fit(X_train_df)
+
+    if queue and queue.sycl_device.is_gpu:
+        # KMeans Init Dense GPU implementation is different from CPU
+        expected_cluster_labels = np.array([0, 1], dtype=np.int32)
+        expected_cluster_centers = np.array([[1.0, 2.0], [10.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+    else:
+        expected_cluster_labels = np.array([1, 0], dtype=np.int32)
+        expected_cluster_centers = np.array([[10.0, 2.0], [1.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+
+    assert_allclose(expected_cluster_labels, _as_numpy(kmeans.predict(X_test_df)))
+    assert_allclose(expected_cluster_centers, _as_numpy(kmeans.cluster_centers_))
+    assert expected_inertia == kmeans.inertia_
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("init", ["k-means++", "random", "arraylike"])
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@pytest.mark.parametrize(
+    "dims", [(1000, 10, 0.95, 3), (50000, 100, 0.75, 10), (10000, 10, 0.8, 5)]
+)
+def test_dense_vs_sparse(queue, init, algorithm, dims):
+    from sklearnex.cluster import KMeans
+
+    if init == "random":
+        pytest.skip("Random initialization in sparse K-means is buggy.")
+
+    # For higher level of sparsity (smaller density) the test may fail
+    n_samples, n_features, density, n_clusters = dims
+    X_dense = generate_dense_dataset(n_samples, n_features, density, n_clusters)
+    X_sparse = csr_matrix(X_dense)
+
+    if init == "arraylike":
+        np.random.seed(2024 + n_samples + n_features + n_clusters)
+        init = X_dense[np.random.choice(n_samples, size=n_clusters, replace=False)]
+
+    kmeans_dense = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_dense)
+    kmeans_sparse = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_sparse)
+
+    assert_allclose(
+        kmeans_dense.cluster_centers_,
+        kmeans_sparse.cluster_centers_,
+    )

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -35,7 +35,7 @@ from sklearnex import config_context
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain, register_hyperparameters
 from ..metrics import pairwise_distances
-from ..utils import get_namespace
+from ..utils._array_api import get_namespace
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
@@ -115,9 +115,9 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
         )
         return patching_status
 
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit()
+        self._onedal_estimator.finalize_fit(queue=queue)
         self._need_to_finalize = False
 
         if not daal_check_version((2024, "P", 400)) and self.assume_centered:
@@ -192,7 +192,7 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
             else:
                 self.n_samples_seen_ += X.shape[0]
 
-            self._onedal_estimator.partial_fit(X, queue)
+            self._onedal_estimator.partial_fit(X, queue=queue)
         finally:
             self._need_to_finalize = True
 
@@ -326,7 +326,7 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
             X_batch = X[batch]
             self._onedal_partial_fit(X_batch, queue=queue, check_input=False)
 
-        self._onedal_finalize_fit()
+        self._onedal_finalize_fit(queue=queue)
 
         return self
 

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/covariance/tests/test_incremental_covariance.py

@@ -26,6 +26,7 @@ from sklearn.covariance.tests.test_covariance import (
 from sklearn.datasets import load_diabetes
 from sklearn.decomposition import PCA
 
+from daal4py.sklearn._utils import daal_check_version
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
@@ -37,6 +38,11 @@ from onedal.tests.utils._dataframes_support import (
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("assume_centered", [True, False])
 def test_sklearnex_partial_fit_on_gold_data(dataframe, queue, dtype, assume_centered):
+    is_gpu = queue is not None and queue.sycl_device.is_gpu
+    if assume_centered and is_gpu and not daal_check_version((2025, "P", 0)):
+        pytest.skip(
+            "Due to a bug on oneDAL side, means are not set to zero when assume_centered=True"
+        )
     from sklearnex.covariance import IncrementalEmpiricalCovariance
 
     X = np.array([[0, 1], [0, 1]])
@@ -143,6 +149,11 @@ def test_sklearnex_partial_fit_on_random_data(
 def test_sklearnex_fit_on_random_data(
     dataframe, queue, num_batches, row_count, column_count, dtype, assume_centered
 ):
+    is_gpu = queue is not None and queue.sycl_device.is_gpu
+    if assume_centered and is_gpu and not daal_check_version((2025, "P", 0)):
+        pytest.skip(
+            "Due to a bug on oneDAL side, means are not set to zero when assume_centered=True"
+        )
     from sklearnex.covariance import IncrementalEmpiricalCovariance
 
     seed = 77

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -32,7 +32,7 @@ if daal_check_version((2024, "P", 100)):
 
     from .._device_offload import dispatch, wrap_output_data
     from .._utils import PatchingConditionsChain
-    from ..utils import get_namespace
+    from ..utils._array_api import get_namespace
 
     if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
         from sklearn.utils import check_scalar

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -48,7 +48,6 @@ def get_patch_map_core(preview=False):
             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,
             )
@@ -60,14 +59,6 @@ def get_patch_map_core(preview=False):
             # when preview is used, setting the mapping element[1] to None
             # should NOT be done. This may lose track of the unpatched
             # sklearn estimator or function.
-            # KMeans
-            cluster_module, _, _ = mapping["kmeans"][0][0]
-            sklearn_obj = mapping["kmeans"][0][1]
-            mapping.pop("kmeans")
-            mapping["kmeans"] = [
-                [(cluster_module, "KMeans", KMeans_sklearnex), sklearn_obj]
-            ]
-
             # Covariance
             mapping["empiricalcovariance"] = [
                 [
@@ -143,6 +134,7 @@ def get_patch_map_core(preview=False):
             from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
 
         from .cluster import DBSCAN as DBSCAN_sklearnex
+        from .cluster import KMeans as KMeans_sklearnex
         from .covariance import (
             IncrementalEmpiricalCovariance as IncrementalEmpiricalCovariance_sklearnex,
         )
@@ -155,6 +147,7 @@ def get_patch_map_core(preview=False):
         from .linear_model import (
             IncrementalLinearRegression as IncrementalLinearRegression_sklearnex,
         )
+        from .linear_model import IncrementalRidge as IncrementalRidge_sklearnex
         from .linear_model import Lasso as Lasso_sklearnex
         from .linear_model import LinearRegression as LinearRegression_sklearnex
         from .linear_model import LogisticRegression as LogisticRegression_sklearnex
@@ -176,6 +169,10 @@ def get_patch_map_core(preview=False):
         mapping.pop("dbscan")
         mapping["dbscan"] = [[(cluster_module, "DBSCAN", DBSCAN_sklearnex), None]]
 
+        # KMeans
+        mapping.pop("kmeans")
+        mapping["kmeans"] = [[(cluster_module, "KMeans", KMeans_sklearnex), None]]
+
         # PCA
         mapping.pop("pca")
         mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
@@ -412,6 +409,19 @@ def get_patch_map_core(preview=False):
             ]
         ]
 
+        if daal_check_version((2024, "P", 600)):
+            # IncrementalRidge
+            mapping["incrementalridge"] = [
+                [
+                    (
+                        linear_model_module,
+                        "IncrementalRidge",
+                        IncrementalRidge_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+
         # Configs
         mapping["set_config"] = [
             [(base_module, "set_config", set_config_sklearnex), None]