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

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/utils/_dpep_helpers.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
-""" Utilities for Data Parallel Extensions libs, such as DPNP, DPCtl.
+"""Utilities for Data Parallel Extensions libs, such as DPNP, DPCtl.
 See `Data Parallel Extensions for Python <https://github.com/IntelPython/DPEP>`__
 """
 
@@ -54,3 +54,18 @@ def is_dpnp_available(version=None):
 
 dpctl_available = is_dpctl_available()
 dpnp_available = is_dpnp_available()
+
+
+if dpnp_available:
+    import dpnp
+if dpctl_available:
+    import dpctl.tensor as dpt
+
+
+def get_unique_values_with_dpep(X):
+    if dpnp_available:
+        return dpnp.unique(X)
+    elif dpctl_available:
+        return dpt.unique_values(X)
+    else:
+        raise RuntimeError("No DPEP package available to provide `unique` function.")

scikit_learn_intelex-2025.5.0.data/data/Lib/site-packages/onedal/utils/_sycl_queue_manager.py

@@ -0,0 +1,147 @@
+# ==============================================================================
+# Copyright 2025 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 contextlib import contextmanager
+
+from .._config import _get_config
+from ..utils._dpep_helpers import dpctl_available
+
+if dpctl_available:
+    from dpctl import SyclQueue
+else:
+    from onedal import _dpc_backend
+
+    SyclQueue = getattr(_dpc_backend, "SyclQueue", None)
+
+# single instance of global queue
+__global_queue = None
+
+
+def __create_sycl_queue(target):
+    if SyclQueue is None:
+        # we don't have SyclQueue support
+        return None
+    if target is None:
+        return None
+    if isinstance(target, SyclQueue):
+        return target
+    if isinstance(target, (str, int)):
+        return SyclQueue(target)
+    raise ValueError(f"Invalid queue or device selector {target=}.")
+
+
+def get_global_queue():
+    """Get the global queue. Retrieve it from the config if not set."""
+    if (queue := __global_queue) is not None:
+        if SyclQueue and not isinstance(queue, SyclQueue):
+            raise ValueError("Global queue is not a SyclQueue object.")
+        return queue
+
+    target = _get_config()["target_offload"]
+    if target == "auto":
+        # queue will be created from the provided data to each function call
+        return None
+
+    q = __create_sycl_queue(target)
+    update_global_queue(q)
+    return q
+
+
+def remove_global_queue():
+    """Remove the global queue."""
+    global __global_queue
+    __global_queue = None
+
+
+def update_global_queue(queue):
+    """Update the global queue."""
+    global __global_queue
+    queue = __create_sycl_queue(queue)
+    __global_queue = queue
+
+
+def from_data(*data):
+    """Extract the queue from provided data. This updates the global queue as well."""
+    for item in data:
+        # iterate through all data objects, extract the queue, and verify that all data objects are on the same device
+        try:
+            usm_iface = getattr(item, "__sycl_usm_array_interface__", None)
+        except RuntimeError as e:
+            if "SUA interface" in str(e):
+                # ignore SUA interface errors and move on
+                continue
+            else:
+                # unexpected, re-raise
+                raise e
+
+        if usm_iface is None:
+            # no interface found - try next data object
+            continue
+
+        # extract the queue
+        global_queue = get_global_queue()
+        data_queue = usm_iface["syclobj"]
+        if not data_queue:
+            # no queue, i.e. host data, no more work to do
+            continue
+
+        # update the global queue if not set
+        if global_queue is None:
+            update_global_queue(data_queue)
+            global_queue = data_queue
+
+        # if either queue points to a device, assert it's always the same device
+        data_dev = data_queue.sycl_device
+        global_dev = global_queue.sycl_device
+        if (data_dev and global_dev) is not None and data_dev != global_dev:
+            raise ValueError(
+                "Data objects are located on different target devices or not on selected device."
+            )
+
+    # after we went through the data, global queue is updated and verified (if any queue found)
+    return get_global_queue()
+
+
+@contextmanager
+def manage_global_queue(queue, *args):
+    """
+    Context manager to manage the global SyclQueue.
+
+    This context manager updates the global queue with the provided queue,
+    verifies that all data objects are on the same device, and restores the
+    original queue after work is done.
+    Note: For most applications, the original queue should be `None`, but
+            if there are nested calls to `manage_global_queue()`, it is
+            important to restore the outer queue, rather than setting it to
+            `None`.
+
+    Parameters:
+    queue (SyclQueue or None): The queue to set as the global queue. If None,
+                                the global queue will be determined from the provided data.
+    *args: Additional data objects to verify their device placement.
+
+    Yields:
+    SyclQueue: The global queue after verification.
+    """
+    original_queue = get_global_queue()
+    try:
+        # update the global queue with what is provided, it can be None, then we will get it from provided data
+        update_global_queue(queue)
+        # find the queues in data to verify that all data objects are on the same device
+        yield from_data(*args)
+    finally:
+        # restore the original queue
+        update_global_queue(original_queue)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/utils/tests/test_validation.py

@@ -40,7 +40,7 @@ from onedal.utils.validation import assert_all_finite
 )
 @pytest.mark.parametrize("allow_nan", [False, True])
 @pytest.mark.parametrize(
-    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl,array_api")
 )
 def test_sum_infinite_actually_finite(dtype, shape, allow_nan, dataframe, queue):
     X = np.empty(shape, dtype=dtype)
@@ -65,7 +65,7 @@ def test_sum_infinite_actually_finite(dtype, shape, allow_nan, dataframe, queue)
 @pytest.mark.parametrize("check", ["inf", "NaN", None])
 @pytest.mark.parametrize("seed", [0, 123456])
 @pytest.mark.parametrize(
-    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl,array_api")
 )
 def test_assert_finite_random_location(
     dtype, shape, allow_nan, check, seed, dataframe, queue
@@ -92,7 +92,7 @@ def test_assert_finite_random_location(
 @pytest.mark.parametrize("check", ["inf", "NaN", None])
 @pytest.mark.parametrize("seed", [0, 123456])
 @pytest.mark.parametrize(
-    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl,array_api")
 )
 def test_assert_finite_random_shape_and_location(
     dtype, allow_nan, check, seed, dataframe, queue

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/utils/validation.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
+import inspect
 import warnings
 from collections.abc import Sequence
 from numbers import Integral
@@ -21,6 +22,9 @@ from numbers import Integral
 import numpy as np
 from scipy import sparse as sp
 
+from onedal.common._backend import BackendFunction
+from onedal.utils import _sycl_queue_manager as QM
+
 if np.lib.NumpyVersion(np.__version__) >= np.lib.NumpyVersion("2.0.0a0"):
     # numpy_version >= 2.0
     from numpy.exceptions import VisibleDeprecationWarning
@@ -34,8 +38,7 @@ from sklearn.utils.validation import check_array
 from daal4py.sklearn.utils.validation import (
     _assert_all_finite as _daal4py_assert_all_finite,
 )
-from onedal import _backend
-from onedal.common._policy import _get_policy
+from onedal import _default_backend as backend
 from onedal.datatypes import to_table
 
 
@@ -127,6 +130,16 @@ def _validate_targets(y, class_weight, dtype):
     return np.asarray(y, dtype=dtype, order="C"), class_weight_res, classes
 
 
+def get_finite_keyword():
+    """Gets the argument name for scikit-learn's validation functions compatible with
+    the current version of scikit-learn and using function inspection instead of
+    version check due to `onedal` design rule: sklearn versioning should occur
+    in `sklearnex` module."""
+    if "ensure_all_finite" in inspect.signature(check_array).parameters:
+        return "ensure_all_finite"
+    return "force_all_finite"
+
+
 def _check_array(
     array,
     dtype="numeric",
@@ -136,6 +149,7 @@ def _check_array(
     force_all_finite=True,
     ensure_2d=True,
     accept_large_sparse=True,
+    _finite_keyword=get_finite_keyword(),
 ):
     if force_all_finite:
         if sp.issparse(array):
@@ -145,15 +159,19 @@ def _check_array(
         else:
             _daal4py_assert_all_finite(array)
             force_all_finite = False
+    check_kwargs = {
+        "array": array,
+        "dtype": dtype,
+        "accept_sparse": accept_sparse,
+        "order": order,
+        "copy": copy,
+        "ensure_2d": ensure_2d,
+        "accept_large_sparse": accept_large_sparse,
+    }
+    check_kwargs[_finite_keyword] = force_all_finite
+
     array = check_array(
-        array=array,
-        dtype=dtype,
-        accept_sparse=accept_sparse,
-        order=order,
-        copy=copy,
-        force_all_finite=force_all_finite,
-        ensure_2d=ensure_2d,
-        accept_large_sparse=accept_large_sparse,
+        **check_kwargs,
     )
 
     if sp.issparse(array):
@@ -437,18 +455,22 @@ def _is_csr(x):
 
 
 def _assert_all_finite(X, allow_nan=False, input_name=""):
-    policy = _get_policy(None, X)
+    backend_method = BackendFunction(
+        backend.finiteness_checker.compute.compute, backend, "compute", no_policy=False
+    )
     X_t = to_table(X)
     params = {
         "fptype": X_t.dtype,
         "method": "dense",
         "allow_nan": allow_nan,
     }
-    if not _backend.finiteness_checker.compute.compute(policy, params, X_t).finite:
-        type_err = "infinity" if allow_nan else "NaN, infinity"
-        padded_input_name = input_name + " " if input_name else ""
-        msg_err = f"Input {padded_input_name}contains {type_err}."
-        raise ValueError(msg_err)
+    with QM.manage_global_queue(None, X):
+        # Must use the queue provided by X
+        if not backend_method(params, X_t).finite:
+            type_err = "infinity" if allow_nan else "NaN, infinity"
+            padded_input_name = input_name + " " if input_name else ""
+            msg_err = f"Input {padded_input_name}contains {type_err}."
+            raise ValueError(msg_err)
 
 
 def assert_all_finite(
@@ -462,3 +484,12 @@ def assert_all_finite(
         allow_nan=allow_nan,
         input_name=input_name,
     )
+
+
+def is_contiguous(X):
+    if hasattr(X, "flags"):
+        return X.flags["C_CONTIGUOUS"] or X.flags["F_CONTIGUOUS"]
+    elif hasattr(X, "__dlpack__"):
+        return backend.dlpack_memory_order(X) is not None
+    else:
+        return False

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/__init__.py

@@ -52,12 +52,13 @@ __all__ = [
     "unpatch_sklearn",
     "utils",
 ]
+__version__ = "2199.9.9"
 onedal_iface_flag = os.environ.get("OFF_ONEDAL_IFACE", "0")
 if onedal_iface_flag == "0":
-    from onedal import _is_spmd_backend
+    from onedal import _spmd_backend
     from onedal.common.hyperparameters import get_hyperparameters
 
-    if _is_spmd_backend:
+    if _spmd_backend is not None:
         __all__.append("spmd")
 
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/__main__.py

@@ -25,9 +25,9 @@ def _main():
     parser = argparse.ArgumentParser(
         prog="python -m sklearnex",
         description="""
-            Run your Python script with Intel(R) Extension for
+            Run your Python script with Extension for
             scikit-learn, optimizing solvers of
-            scikit-learn with Intel(R) oneAPI Data Analytics Library.
+            scikit-learn with oneAPI Data Analytics Library.
             """,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/_config.py

@@ -26,10 +26,12 @@ from onedal._config import _get_config as onedal_get_config
 
 def get_config():
     """Retrieve current values for configuration set by :func:`set_config`
+
     Returns
     -------
     config : dict
         Keys are parameter names that can be passed to :func:`set_config`.
+
     See Also
     --------
     config_context : Context manager for global configuration.
@@ -44,28 +46,45 @@ def set_config(
     target_offload=None,
     allow_fallback_to_host=None,
     allow_sklearn_after_onedal=None,
+    use_raw_input=None,
     **sklearn_configs,
 ):
     """Set global configuration
+
     Parameters
     ----------
-    target_offload : string or dpctl.SyclQueue, default=None
+    target_offload : string or dpctl.SyclQueue or None, default=None
         The device primarily used to perform computations.
         If string, expected to be "auto" (the execution context
         is deduced from input data location),
         or SYCL* filter selector string. Global default: "auto".
-    allow_fallback_to_host : bool, default=None
+
+    allow_fallback_to_host : bool or None, default=None
         If True, allows to fallback computation to host device
         in case particular estimator does not support the selected one.
         Global default: False.
-    allow_sklearn_after_onedal : bool, default=None
+
+    allow_sklearn_after_onedal : bool or None, default=None
         If True, allows to fallback computation to sklearn after onedal
         backend in case of runtime error on onedal backend computations.
         Global default: True.
+
+    use_raw_input : bool or None, default=None
+        .. deprecated:: 2026.0
+        If True, uses the raw input data in some SPMD onedal backend computations
+        without any checks on data consistency or validity.
+        Not recommended for general use.
+        Global default: False.
+
     See Also
     --------
     config_context : Context manager for global configuration.
     get_config : Retrieve current values of the global configuration.
+
+    Warnings
+    --------
+    Using ``use_raw_input=True`` is not recommended for general use as it
+    bypasses data consistency checks, which may lead to unexpected behavior.
     """
 
     array_api_dispatch = sklearn_configs.get("array_api_dispatch", False)
@@ -82,30 +101,53 @@ def set_config(
         local_config["allow_fallback_to_host"] = allow_fallback_to_host
     if allow_sklearn_after_onedal is not None:
         local_config["allow_sklearn_after_onedal"] = allow_sklearn_after_onedal
+    if use_raw_input is not None:
+        local_config["use_raw_input"] = use_raw_input
 
 
 @contextmanager
 def config_context(**new_config):
     """Context manager for global scikit-learn configuration
+
     Parameters
     ----------
-    target_offload : string or dpctl.SyclQueue, default=None
+    target_offload : string or dpctl.SyclQueue or None, default=None
         The device primarily used to perform computations.
         If string, expected to be "auto" (the execution context
         is deduced from input data location),
         or SYCL* filter selector string. Global default: "auto".
-    allow_fallback_to_host : bool, default=None
+
+    allow_fallback_to_host : bool or None, default=None
         If True, allows to fallback computation to host device
         in case particular estimator does not support the selected one.
         Global default: False.
-    Notes
+
+    allow_sklearn_after_onedal : bool or None, default=None
+        If True, allows to fallback computation to sklearn after onedal
+        backend in case of runtime error on onedal backend computations.
+        Global default: True.
+
+    use_raw_input : bool or None, default=None
+        .. deprecated:: 2026.0
+        If True, uses the raw input data in some SPMD onedal backend computations
+        without any checks on data consistency or validity.
+        Not recommended for general use.
+        Global default: False.
+
+    Note
     -----
     All settings, not just those presently modified, will be returned to
     their previous values when the context manager is exited.
+
     See Also
     --------
     set_config : Set global scikit-learn configuration.
     get_config : Retrieve current values of the global configuration.
+
+    Warnings
+    --------
+    Using ``use_raw_input=True`` is not recommended for general use as it
+    bypasses data consistency checks, which may lead to unexpected behavior.
     """
     old_config = get_config()
     set_config(**new_config)

scikit_learn_intelex-2025.5.0.data/data/Lib/site-packages/sklearnex/_device_offload.py

@@ -0,0 +1,143 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from functools import wraps
+
+from onedal._device_offload import _copy_to_usm, _transfer_to_host
+from onedal.utils import _sycl_queue_manager as QM
+from onedal.utils._array_api import _asarray
+from onedal.utils._dpep_helpers import dpnp_available
+
+if dpnp_available:
+    import dpnp
+    from onedal.utils._array_api import _convert_to_dpnp
+
+from ._config import get_config
+
+
+def _get_backend(obj, queue, method_name, *data):
+    with QM.manage_global_queue(queue, *data) as queue:
+        cpu_device = queue is None or getattr(queue.sycl_device, "is_cpu", True)
+        gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
+
+        if cpu_device:
+            patching_status = obj._onedal_cpu_supported(method_name, *data)
+            if patching_status.get_status():
+                return "onedal", patching_status
+            else:
+                return "sklearn", patching_status
+
+        allow_fallback_to_host = get_config()["allow_fallback_to_host"]
+
+        if gpu_device:
+            patching_status = obj._onedal_gpu_supported(method_name, *data)
+            if patching_status.get_status():
+                return "onedal", patching_status
+            else:
+                QM.remove_global_queue()
+                if allow_fallback_to_host:
+                    patching_status = obj._onedal_cpu_supported(method_name, *data)
+                    if patching_status.get_status():
+                        return "onedal", patching_status
+                    else:
+                        return "sklearn", patching_status
+                else:
+                    return "sklearn", patching_status
+
+    raise RuntimeError("Device support is not implemented")
+
+
+def get_array_api_support_tag(estimator):
+    """Gets the value of the 'array_api_support' tag from the estimator
+    using correct code path depending on the scikit-learn version."""
+    if hasattr(estimator, "__sklearn_tags__"):
+        return estimator.__sklearn_tags__().array_api_support
+    elif hasattr(estimator, "_get_tags"):
+        tags = estimator._get_tags()
+        if "array_api_support" in tags:
+            return tags["array_api_support"]
+    return False
+
+
+def dispatch(obj, method_name, branches, *args, **kwargs):
+    if get_config()["use_raw_input"] is False:
+        with QM.manage_global_queue(None, *args) as queue:
+            has_usm_data_for_args, hostargs = _transfer_to_host(*args)
+            has_usm_data_for_kwargs, hostvalues = _transfer_to_host(*kwargs.values())
+            hostkwargs = dict(zip(kwargs.keys(), hostvalues))
+
+            backend, patching_status = _get_backend(obj, queue, method_name, *hostargs)
+            has_usm_data = has_usm_data_for_args or has_usm_data_for_kwargs
+            if backend == "onedal":
+                # Host args only used before onedal backend call.
+                # Device will be offloaded when onedal backend will be called.
+                patching_status.write_log(queue=queue, transferred_to_host=False)
+                return branches[backend](obj, *hostargs, **hostkwargs, queue=queue)
+            if backend == "sklearn":
+                if (
+                    "array_api_dispatch" in get_config()
+                    and get_config()["array_api_dispatch"]
+                    and get_array_api_support_tag(obj)
+                    and not has_usm_data
+                ):
+                    # USM ndarrays are also excluded for the fallback Array API. Currently, DPNP.ndarray is
+                    # not compliant with the Array API standard, and DPCTL usm_ndarray Array API is compliant,
+                    # except for the linalg module. There is no guarantee that stock scikit-learn will
+                    # work with such input data. The condition will be updated after DPNP.ndarray and
+                    # DPCTL usm_ndarray enabling for conformance testing and these arrays supportance
+                    # of the fallback cases.
+                    # If `array_api_dispatch` enabled and array api is supported for the stock scikit-learn,
+                    # then raw inputs are used for the fallback.
+                    patching_status.write_log(transferred_to_host=False)
+                    return branches[backend](obj, *args, **kwargs)
+                else:
+                    patching_status.write_log()
+                    return branches[backend](obj, *hostargs, **hostkwargs)
+        raise RuntimeError(
+            f"Undefined backend {backend} in " f"{obj.__class__.__name__}.{method_name}"
+        )
+    else:
+        return branches["onedal"](obj, *args, **kwargs)
+
+
+def wrap_output_data(func):
+    """
+    Converts and moves the output arrays of the decorated function
+    to match the input array type and device.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        result = func(self, *args, **kwargs)
+        if not (len(args) == 0 and len(kwargs) == 0):
+            data = (*args, *kwargs.values())
+            usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
+            if usm_iface is not None:
+                result = _copy_to_usm(usm_iface["syclobj"], result)
+                if dpnp_available and isinstance(data[0], dpnp.ndarray):
+                    result = _convert_to_dpnp(result)
+                return result
+            config = get_config()
+            if not ("transform_output" in config and config["transform_output"]):
+                input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
+                if input_array_api:
+                    input_array_api_device = data[0].device
+                    result = _asarray(
+                        result, input_array_api, device=input_array_api_device
+                    )
+        return result
+
+    return wrapper

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -17,6 +17,7 @@
 import logging
 import os
 import re
+import sys
 import warnings
 from abc import ABC
 
@@ -51,7 +52,7 @@ class PatchingConditionsChain(daal4py_PatchingConditionsChain):
         else:
             self.logger.debug(
                 f"{self.scope_name}: debugging for the patch is enabled to track"
-                " the usage of Intel® oneAPI Data Analytics Library (oneDAL)"
+                " the usage of oneAPI Data Analytics Library (oneDAL)"
             )
             for message in self.messages:
                 self.logger.debug(
@@ -143,7 +144,7 @@ def register_hyperparameters(hyperparameters_map):
 
 # This abstract class is meant to generate a clickable doc link for classses
 # in sklearnex that are not part of base scikit-learn.
-class IntelEstimator(BaseForHTMLDocLink):
+class ExtensionEstimator(BaseForHTMLDocLink):
     @property
     def _doc_link_module(self) -> str:
         return "sklearnex"
@@ -155,6 +156,31 @@ class IntelEstimator(BaseForHTMLDocLink):
         return f"https://uxlfoundation.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"
 
 
+def _add_inc_serialization_note(class_docstrings: str) -> str:
+    """Adds a small note note about serialization for extension estimators that are incremental.
+    The class docstrings should leave a placeholder '%incremental_serialization_note%' inside
+    their docstrings, which will be replaced by this note.
+    """
+    # In python versions >=3.13, leading whitespace in docstrings defined through
+    # static strings (but **not through other ways**) is automatically removed
+    # from the final docstrings, while in earlier versions is kept.
+    inc_serialization_note = """Note
+----
+Serializing instances of this class will trigger a forced finalization of calculations
+when the inputs are in a sycl queue or when using GPUs. Since (internal method)
+finalize_fit can't be dispatched without directly provided queue and the dispatching
+policy can't be serialized, the computation is finalized during serialization call and
+the policy is not saved in serialized data."""
+    if sys.version_info.major == 3 and sys.version_info.minor <= 12:
+        inc_serialization_note = re.sub(
+            r"^", " " * 4, inc_serialization_note, flags=re.MULTILINE
+        )
+        inc_serialization_note = inc_serialization_note.strip()
+    return class_docstrings.replace(
+        r"%incremental_serialization_note%", inc_serialization_note
+    )
+
+
 # This abstract class is meant to generate a clickable doc link for classses
 # in sklearnex that have counterparts in scikit-learn.
 class PatchableEstimator(BaseForHTMLDocLink):