scikit-learn-intelex 2025.10.0__py313-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/_n_jobs_support.py

@@ -0,0 +1,252 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import logging
+import sys
+import threading
+from functools import wraps
+from inspect import Parameter, signature
+from multiprocessing import cpu_count
+from numbers import Integral
+from warnings import warn
+
+import threadpoolctl
+
+from daal4py import daalinit as set_n_threads
+from daal4py import num_threads as get_n_threads
+
+from ._utils import sklearn_check_version
+
+if sklearn_check_version("1.2"):
+    from sklearn.utils._param_validation import validate_parameter_constraints
+
+
+# Note: getting controller in global scope of this module is required
+# to avoid overheads by its initialization per each function call
+threadpool_controller = threadpoolctl.ThreadpoolController()
+
+
+def get_suggested_n_threads(n_cpus):
+    """
+    Function to get `n_threads` limit
+    if `n_jobs` is set in upper parallelization context.
+    Usually, limit is equal to `n_logical_cpus` // `n_jobs`.
+    Returns None if limit is not set.
+    """
+    n_threads_map = {
+        lib_ctl.internal_api: lib_ctl.get_num_threads()
+        for lib_ctl in threadpool_controller.lib_controllers
+        if lib_ctl.internal_api != "mkl"
+    }
+    # openBLAS is limited to 24, 64 or 128 threads by default
+    # depending on SW/HW configuration.
+    # thus, these numbers of threads from openBLAS are uninformative
+    if "openblas" in n_threads_map and n_threads_map["openblas"] in [24, 64, 128]:
+        del n_threads_map["openblas"]
+    # remove default values equal to n_cpus as uninformative
+    for backend in list(n_threads_map.keys()):
+        if n_threads_map[backend] == n_cpus:
+            del n_threads_map[backend]
+    if len(n_threads_map) > 0:
+        return min(n_threads_map.values())
+    else:
+        return None
+
+
+def _run_with_n_jobs(method):
+    """
+    Decorator for running of methods containing oneDAL kernels with 'n_jobs'.
+
+    Outside actual call of decorated method, this decorator:
+    - checks correctness of passed 'n_jobs',
+    - deducts actual number of threads to use,
+    - sets and resets this number for oneDAL environment.
+    """
+
+    @wraps(method)
+    def n_jobs_wrapper(self, *args, **kwargs):
+        # threading parallel backend branch
+        if not isinstance(threading.current_thread(), threading._MainThread):
+            warn(
+                "'Threading' parallel backend is not supported by "
+                "Extension for Scikit-learn*. "
+                "Falling back to usage of all available threads."
+            )
+            result = method(self, *args, **kwargs)
+            return result
+        # multiprocess parallel backends branch
+        # preemptive validation of n_jobs parameter is required
+        # because '_run_with_n_jobs' decorator is applied on top of method
+        # where validation takes place
+        if sklearn_check_version("1.2") and hasattr(self, "_parameter_constraints"):
+            validate_parameter_constraints(
+                parameter_constraints={"n_jobs": self._parameter_constraints["n_jobs"]},
+                params={"n_jobs": self.n_jobs},
+                caller_name=self.__class__.__name__,
+            )
+        # search for specified n_jobs
+        n_jobs = self.n_jobs
+        n_cpus = cpu_count()
+        # receive n_threads limitation from upper parallelism context
+        # using `threadpoolctl.ThreadpoolController`
+        n_threads = get_suggested_n_threads(n_cpus)
+        # get real `n_jobs` number of threads for oneDAL
+        # using sklearn rules and `n_threads` from upper parallelism context
+        if n_jobs is None or n_jobs == 0:
+            if n_threads is None:
+                # default branch with no setting for n_jobs
+                return method(self, *args, **kwargs)
+            else:
+                n_jobs = n_threads
+        elif n_jobs < 0:
+            if n_threads is None:
+                n_jobs = max(1, n_cpus + n_jobs + 1)
+            else:
+                n_jobs = max(1, n_threads + n_jobs + 1)
+        # branch with set n_jobs
+        old_n_threads = get_n_threads()
+        if n_jobs == old_n_threads:
+            return method(self, *args, **kwargs)
+
+        try:
+            logger = logging.getLogger("sklearnex")
+            cl = self.__class__
+            logger.debug(
+                f"{cl.__module__}.{cl.__name__}.{method.__name__}: "
+                f"setting {n_jobs} threads (previous - {old_n_threads})"
+            )
+            set_n_threads(n_jobs)
+            return method(self, *args, **kwargs)
+        finally:
+            set_n_threads(old_n_threads)
+
+    return n_jobs_wrapper
+
+
+def control_n_jobs(decorated_methods: list = []):
+    """
+    Decorator for controlling the 'n_jobs' parameter in an estimator class.
+
+    This decorator is designed to be applied to both estimators with and without
+    native support for the 'n_jobs' parameter in the original Scikit-learn APIs.
+    When applied to an estimator without 'n_jobs' support in
+    its original '__init__' method, this decorator adds the 'n_jobs' parameter.
+
+    Additionally, this decorator allows for fine-grained control over which methods
+    should be executed with the 'n_jobs' parameter. The methods specified in
+    the 'decorated_methods' argument will run with 'n_jobs',
+    while all other methods remain unaffected.
+
+    Parameters
+    ----------
+    decorated_methods: list
+        A list of method names to be executed with 'n_jobs'.
+
+    Example
+    -------
+        @control_n_jobs(decorated_methods=['fit', 'predict'])
+
+        class MyEstimator:
+
+            def __init__(self, *args, **kwargs):
+                # Your original __init__ implementation here
+
+            def fit(self, *args, **kwargs):
+                # Your original fit implementation here
+
+            def predict(self, *args, **kwargs):
+                # Your original predict implementation here
+
+            def other_method(self, *args, **kwargs):
+                # Methods not listed in decorated_methods will not be affected by 'n_jobs'
+                pass
+    """
+
+    def class_wrapper(original_class):
+        original_class._n_jobs_supported_onedal_methods = decorated_methods.copy()
+
+        original_init = original_class.__init__
+
+        if sklearn_check_version("1.2") and hasattr(
+            original_class, "_parameter_constraints"
+        ):
+            parameter_constraints = original_class._parameter_constraints
+            if "n_jobs" not in parameter_constraints:
+                parameter_constraints["n_jobs"] = [Integral, None]
+
+        @wraps(original_init)
+        def init_with_n_jobs(self, *args, n_jobs=None, **kwargs):
+            original_init(self, *args, **kwargs)
+            self.n_jobs = n_jobs
+
+        # add "n_jobs" parameter to signature of wrapped init
+        # if estimator doesn't originally support it
+        sig = signature(original_init)
+        if "n_jobs" not in sig.parameters:
+            params_copy = sig.parameters.copy()
+            params_copy.update(
+                {
+                    "n_jobs": Parameter(
+                        name="n_jobs", kind=Parameter.KEYWORD_ONLY, default=None
+                    )
+                }
+            )
+            init_with_n_jobs.__signature__ = sig.replace(parameters=params_copy.values())
+            original_class.__init__ = init_with_n_jobs
+
+        # add n_jobs to __doc__ string if needed
+        if (
+            hasattr(original_class, "__doc__")
+            and isinstance(original_class.__doc__, str)
+            and "n_jobs : int" not in original_class.__doc__
+        ):
+            # Python 3.13 removed extra tab in class doc string
+            tab = (
+                "    "
+                if (sys.version_info.major == 3 and sys.version_info.minor < 13)
+                else ""
+            )
+            parameters_doc_tail = f"\n{tab}Attributes"
+            n_jobs_doc = f"""
+{tab}n_jobs : int, default=None
+{tab}    The number of jobs to use in parallel for the computation.
+{tab}    ``None`` means using all physical cores
+{tab}    unless in a :obj:`joblib.parallel_backend` context.
+{tab}    ``-1`` means using all logical cores.
+{tab}    See :term:`Glossary <n_jobs>` for more details.
+"""
+            original_class.__doc__ = original_class.__doc__.replace(
+                parameters_doc_tail, n_jobs_doc + parameters_doc_tail
+            )
+
+        # decorate methods to be run with applied n_jobs parameter
+        for method_name in decorated_methods:
+            # if method doesn't exist, we want it to raise an Exception
+            method = getattr(original_class, method_name)
+            if not hasattr(method, "__onedal_n_jobs_decorated__"):
+                decorated_method = _run_with_n_jobs(method)
+                # sign decorated method for testing and other purposes
+                decorated_method.__onedal_n_jobs_decorated__ = True
+                setattr(original_class, method_name, decorated_method)
+            else:
+                warn(
+                    f"{original_class.__name__}.{method_name} already has "
+                    "oneDAL n_jobs support and will not be decorated."
+                )
+
+        return original_class
+
+    return class_wrapper

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/_utils.py

@@ -0,0 +1,245 @@
+# ==============================================================================
+# Copyright 2014 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 functools
+import os
+import sys
+import warnings
+from typing import Any, Tuple
+
+import numpy as np
+from numpy.lib.recfunctions import require_fields
+from sklearn import __version__ as sklearn_version
+
+from daal4py import _get__daal_link_version__ as dv
+
+DaalVersionTuple = Tuple[int, str, int]
+
+import logging
+
+try:
+    from packaging.version import Version
+except ImportError:
+    from distutils.version import LooseVersion as Version
+
+try:
+    from pandas import DataFrame
+    from pandas.core.dtypes.cast import find_common_type
+
+    pandas_is_imported = True
+except (ImportError, ModuleNotFoundError):
+    pandas_is_imported = False
+
+
+def set_idp_sklearn_verbose():
+    logLevel = os.environ.get("IDP_SKLEARN_VERBOSE")
+    try:
+        if logLevel is not None:
+            logging.basicConfig(
+                stream=sys.stdout,
+                format="%(levelname)s: %(message)s",
+                level=logLevel.upper(),
+            )
+    except Exception:
+        warnings.warn(
+            'Unknown level "{}" for logging.\n'
+            'Please, use one of "CRITICAL", "ERROR", '
+            '"WARNING", "INFO", "DEBUG".'.format(logLevel)
+        )
+
+
+def get_daal_version() -> DaalVersionTuple:
+    return int(dv()[0:4]), str(dv()[10:11]), int(dv()[4:8])
+
+
+@functools.lru_cache(maxsize=256, typed=False)
+def daal_check_version(
+    required_version: Tuple[Any, ...],
+    daal_version: Tuple[Any, ...] = get_daal_version(),
+) -> bool:
+    """Check daal version provided as (MAJOR, STATUS, MINOR+PATCH)
+
+    This function also accepts a list or tuple of daal versions. It will return true if
+    any version in the list/tuple is <= `daal_version`.
+    """
+    if isinstance(required_version[0], (list, tuple)):
+        # a list of version candidates was provided, recursively check if any is <= daal_version
+        return any(
+            map(lambda ver: daal_check_version(ver, daal_version), required_version)
+        )
+
+    major_required, status_required, patch_required = required_version
+    major, status, patch = daal_version
+
+    if status != status_required:
+        return False
+
+    if major_required < major:
+        return True
+    if major == major_required:
+        return patch_required <= patch
+
+    return False
+
+
+def _package_check_version(version_to_check, available_version):
+    if hasattr(Version(version_to_check), "base_version"):
+        base_package_version = Version(available_version).base_version
+        res = bool(Version(base_package_version) >= Version(version_to_check))
+    else:
+        # packaging module not available
+        res = bool(Version(available_version) >= Version(version_to_check))
+    return res
+
+
+@functools.lru_cache(maxsize=256, typed=False)
+def sklearn_check_version(ver):
+    return _package_check_version(ver, sklearn_version)
+
+
+def parse_dtype(dt):
+    if dt == np.double:
+        return "double"
+    if dt == np.single:
+        return "float"
+    raise ValueError(f"Input array has unexpected dtype = {dt}")
+
+
+def getFPType(X):
+    if pandas_is_imported:
+        if isinstance(X, DataFrame):
+            dt = find_common_type(X.dtypes.tolist())
+            return parse_dtype(dt)
+
+    dt = getattr(X, "dtype", None)
+    return parse_dtype(dt)
+
+
+def make2d(X):
+    if np.isscalar(X):
+        X = np.asarray(X)[np.newaxis, np.newaxis]
+    elif isinstance(X, np.ndarray) and X.ndim == 1:
+        X = X.reshape((X.size, 1))
+    return X
+
+
+def get_patch_message(s):
+    if s == "daal":
+        message = "running accelerated version on CPU"
+
+    elif s == "sklearn":
+        message = "fallback to original Scikit-learn"
+    elif s == "sklearn_after_daal":
+        message = "failed to run accelerated version, fallback to original Scikit-learn"
+    else:
+        raise ValueError(
+            f"Invalid input - expected one of 'daal','sklearn',"
+            f" 'sklearn_after_daal', got {s}"
+        )
+    return message
+
+
+def is_DataFrame(X):
+    if pandas_is_imported:
+        return isinstance(X, DataFrame)
+    else:
+        return False
+
+
+def get_dtype(X):
+    if pandas_is_imported:
+        return find_common_type(list(X.dtypes)) if is_DataFrame(X) else X.dtype
+    else:
+        return getattr(X, "dtype", None)
+
+
+def get_number_of_types(dataframe):
+    dtypes = getattr(dataframe, "dtypes", None)
+    try:
+        return len(set(dtypes))
+    except TypeError:
+        return 1
+
+
+def check_tree_nodes(tree_nodes):
+    def convert_to_old_tree_nodes(tree_nodes):
+        # conversion from sklearn>=1.3 tree nodes format to previous format:
+        # removal of 'missing_go_to_left' field from node dtype
+        new_field = "missing_go_to_left"
+        new_dtype = tree_nodes.dtype
+        old_dtype = np.dtype(
+            [
+                (key, value[0])
+                for key, value in new_dtype.fields.items()
+                if key != new_field
+            ]
+        )
+        return require_fields(tree_nodes, old_dtype)
+
+    if sklearn_check_version("1.3"):
+        return tree_nodes
+    else:
+        return convert_to_old_tree_nodes(tree_nodes)
+
+
+class PatchingConditionsChain:
+    def __init__(self, scope_name):
+        self.scope_name = scope_name
+        self.patching_is_enabled = True
+        self.messages = []
+        self.logger = logging.getLogger("sklearnex")
+
+    def _iter_conditions(self, conditions_and_messages):
+        result = []
+        for condition, message in conditions_and_messages:
+            result.append(condition)
+            if not condition:
+                self.messages.append(message)
+        return result
+
+    def and_conditions(self, conditions_and_messages, conditions_merging=all):
+        self.patching_is_enabled &= conditions_merging(
+            self._iter_conditions(conditions_and_messages)
+        )
+        return self.patching_is_enabled
+
+    def and_condition(self, condition, message):
+        return self.and_conditions([(condition, message)])
+
+    def or_conditions(self, conditions_and_messages, conditions_merging=all):
+        self.patching_is_enabled |= conditions_merging(
+            self._iter_conditions(conditions_and_messages)
+        )
+        return self.patching_is_enabled
+
+    def write_log(self):
+        if self.patching_is_enabled:
+            self.logger.info(f"{self.scope_name}: {get_patch_message('daal')}")
+        else:
+            self.logger.debug(
+                f"{self.scope_name}: debugging for the patch is enabled to track"
+                " the usage of oneAPI Data Analytics Library (oneDAL)"
+            )
+            for message in self.messages:
+                self.logger.debug(
+                    f"{self.scope_name}: patching failed with cause - {message}"
+                )
+            self.logger.info(f"{self.scope_name}: {get_patch_message('sklearn')}")
+
+    def get_status(self, logs=False):
+        if logs:
+            self.write_log()
+        return self.patching_is_enabled

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/cluster/__init__.py

@@ -0,0 +1,20 @@
+# ==============================================================================
+# Copyright 2014 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 .dbscan import DBSCAN
+from .k_means import KMeans
+
+__all__ = ["KMeans", "DBSCAN"]

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/cluster/dbscan.py

@@ -0,0 +1,165 @@
+# ==============================================================================
+# Copyright 2014 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 numbers
+
+import numpy as np
+from scipy import sparse as sp
+from sklearn.cluster import DBSCAN as DBSCAN_original
+from sklearn.utils import check_array
+from sklearn.utils.validation import _check_sample_weight
+
+import daal4py
+
+from .._n_jobs_support import control_n_jobs
+from .._utils import PatchingConditionsChain, getFPType, make2d, sklearn_check_version
+from ..utils.validation import check_feature_names
+
+if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
+    from sklearn.utils import check_scalar
+
+
+def _daal_dbscan(X, eps=0.5, min_samples=5, sample_weight=None):
+    ww = make2d(sample_weight) if sample_weight is not None else None
+    XX = make2d(X)
+
+    fpt = getFPType(XX)  # codespell:ignore fpt
+    alg = daal4py.dbscan(
+        method="defaultDense",
+        fptype=fpt,  # codespell:ignore fpt
+        epsilon=float(eps),
+        minObservations=int(min_samples),
+        memorySavingMode=False,
+        resultsToCompute="computeCoreIndices",
+    )
+
+    daal_res = alg.compute(XX, ww)
+    assignments = daal_res.assignments.ravel()
+    if daal_res.coreIndices is not None:
+        core_ind = daal_res.coreIndices.ravel()
+    else:
+        core_ind = np.array([], dtype=np.intc)
+
+    return (core_ind, assignments)
+
+
+@control_n_jobs(decorated_methods=["fit"])
+class DBSCAN(DBSCAN_original):
+    __doc__ = DBSCAN_original.__doc__
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {**DBSCAN_original._parameter_constraints}
+
+    def __init__(
+        self,
+        eps=0.5,
+        min_samples=5,
+        metric="euclidean",
+        metric_params=None,
+        algorithm="auto",
+        leaf_size=30,
+        p=None,
+        n_jobs=None,
+    ):
+        self.eps = eps
+        self.min_samples = min_samples
+        self.metric = metric
+        self.metric_params = metric_params
+        self.algorithm = algorithm
+        self.leaf_size = leaf_size
+        self.p = p
+        self.n_jobs = n_jobs
+
+    def fit(self, X, y=None, sample_weight=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+        elif sklearn_check_version("1.1"):
+            check_scalar(
+                self.eps,
+                "eps",
+                target_type=numbers.Real,
+                min_val=0.0,
+                include_boundaries="neither",
+            )
+            check_scalar(
+                self.min_samples,
+                "min_samples",
+                target_type=numbers.Integral,
+                min_val=1,
+                include_boundaries="left",
+            )
+            check_scalar(
+                self.leaf_size,
+                "leaf_size",
+                target_type=numbers.Integral,
+                min_val=1,
+                include_boundaries="left",
+            )
+            if self.p is not None:
+                check_scalar(
+                    self.p,
+                    "p",
+                    target_type=numbers.Real,
+                    min_val=0.0,
+                    include_boundaries="left",
+                )
+            if self.n_jobs is not None:
+                check_scalar(self.n_jobs, "n_jobs", target_type=numbers.Integral)
+        else:
+            if self.eps <= 0.0:
+                raise ValueError(f"eps == {self.eps}, must be > 0.0.")
+
+        check_feature_names(self, X, reset=True)
+
+        if sample_weight is not None:
+            sample_weight = _check_sample_weight(sample_weight, X)
+
+        _patching_status = PatchingConditionsChain("sklearn.cluster.DBSCAN.fit")
+        _dal_ready = _patching_status.and_conditions(
+            [
+                (
+                    self.algorithm in ["auto", "brute"],
+                    f"'{self.algorithm}' algorithm is not supported. "
+                    "Only 'auto' and 'brute' algorithms are supported",
+                ),
+                (
+                    self.metric == "euclidean"
+                    or (self.metric == "minkowski" and self.p == 2),
+                    f"'{self.metric}' (p={self.p}) metric is not supported. "
+                    "Only 'euclidean' or 'minkowski' with p=2 metrics are supported.",
+                ),
+                (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
+            ]
+        )
+
+        _patching_status.write_log()
+        if _dal_ready:
+            X = check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+            core_ind, assignments = _daal_dbscan(
+                X, self.eps, self.min_samples, sample_weight=sample_weight
+            )
+            self.core_sample_indices_ = core_ind
+            self.labels_ = assignments
+            self.components_ = np.take(X, core_ind, axis=0)
+            self.n_features_in_ = X.shape[1]
+            return self
+        return super().fit(X, y, sample_weight=sample_weight)
+
+    def fit_predict(self, X, y=None, sample_weight=None):
+        return super().fit_predict(X, y, sample_weight)
+
+    fit.__doc__ = DBSCAN_original.fit.__doc__
+    fit_predict.__doc__ = DBSCAN_original.fit_predict.__doc__