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

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

@@ -0,0 +1,259 @@
+# ===============================================================================
+# 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 warnings
+from functools import partial
+
+import numpy as np
+from joblib import effective_n_jobs
+from sklearn.exceptions import DataConversionWarning
+from sklearn.metrics import pairwise_distances as pairwise_distances_original
+from sklearn.metrics.pairwise import (
+    _VALID_METRICS,
+    PAIRWISE_BOOLEAN_FUNCTIONS,
+    PAIRWISE_DISTANCE_FUNCTIONS,
+    _pairwise_callable,
+    _parallel_pairwise,
+    check_pairwise_arrays,
+)
+from sklearn.utils.validation import check_non_negative
+
+try:
+    from sklearn.metrics.pairwise import _precompute_metric_params
+except ImportError:
+
+    def _precompute_metric_params(*args, **kwrds):
+        return dict()
+
+
+from scipy.sparse import issparse
+from scipy.spatial import distance
+
+import daal4py
+from daal4py.sklearn.utils.validation import _daal_check_array
+
+from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
+
+if sklearn_check_version("1.3"):
+    from sklearn.utils._param_validation import (
+        Hidden,
+        Integral,
+        StrOptions,
+        validate_params,
+    )
+
+
+def _daal4py_cosine_distance_dense(X):
+    X_fptype = getFPType(X)
+    alg = daal4py.cosine_distance(fptype=X_fptype, method="defaultDense")
+    res = alg.compute(X)
+    return res.cosineDistance
+
+
+def _daal4py_correlation_distance_dense(X):
+    X_fptype = getFPType(X)
+    alg = daal4py.correlation_distance(fptype=X_fptype, method="defaultDense")
+    res = alg.compute(X)
+    return res.correlationDistance
+
+
+def _pairwise_distances(
+    X, Y=None, metric="euclidean", *, n_jobs=None, force_all_finite=True, **kwds
+):
+    if metric not in _VALID_METRICS and not callable(metric) and metric != "precomputed":
+        raise ValueError(
+            "Unknown metric %s. Valid metrics are %s, or 'precomputed', "
+            "or a callable" % (metric, _VALID_METRICS)
+        )
+
+    X = _daal_check_array(
+        X, accept_sparse=["csr", "csc", "coo"], force_all_finite=force_all_finite
+    )
+
+    _patching_status = PatchingConditionsChain("sklearn.metrics.pairwise_distances")
+    _dal_ready = _patching_status.and_conditions(
+        [
+            (
+                metric == "cosine" or metric == "correlation",
+                f"'{metric}' metric is not supported. "
+                "Only 'cosine' and 'correlation' metrics are supported.",
+            ),
+            (Y is None, "Second feature array is not supported."),
+            (not issparse(X), "X is sparse. Sparse input is not supported."),
+            (
+                X.dtype == np.float64,
+                f"{X.dtype} X data type is not supported. Only np.float64 is supported.",
+            ),
+        ]
+    )
+    _patching_status.write_log()
+    if _dal_ready:
+        if metric == "cosine":
+            return _daal4py_cosine_distance_dense(X)
+        if metric == "correlation":
+            return _daal4py_correlation_distance_dense(X)
+        raise ValueError(f"'{metric}' distance is wrong for daal4py.")
+    if metric == "precomputed":
+        if sklearn_check_version("1.6"):
+            X, _ = check_pairwise_arrays(
+                X, Y, precomputed=True, ensure_all_finite=force_all_finite
+            )
+        else:
+            X, _ = check_pairwise_arrays(
+                X, Y, precomputed=True, force_all_finite=force_all_finite
+            )
+        whom = (
+            "`pairwise_distances`. Precomputed distance "
+            " need to have non-negative values."
+        )
+        check_non_negative(X, whom=whom)
+        return X
+    if metric in PAIRWISE_DISTANCE_FUNCTIONS:
+        func = PAIRWISE_DISTANCE_FUNCTIONS[metric]
+    elif callable(metric):
+        if sklearn_check_version("1.6"):
+            func = partial(
+                _pairwise_callable,
+                metric=metric,
+                ensure_all_finite=force_all_finite,
+                **kwds,
+            )
+        else:
+            func = partial(
+                _pairwise_callable,
+                metric=metric,
+                force_all_finite=force_all_finite,
+                **kwds,
+            )
+    else:
+        if issparse(X) or issparse(Y):
+            raise TypeError("scipy distance metrics do not" " support sparse matrices.")
+
+        dtype = bool if metric in PAIRWISE_BOOLEAN_FUNCTIONS else None
+
+        if dtype == bool and (X.dtype != bool or (Y is not None and Y.dtype != bool)):
+            msg = "Data was converted to boolean for metric %s" % metric
+            warnings.warn(msg, DataConversionWarning)
+
+        if sklearn_check_version("1.6"):
+            X, Y = check_pairwise_arrays(
+                X, Y, dtype=dtype, ensure_all_finite=force_all_finite
+            )
+        else:
+            X, Y = check_pairwise_arrays(
+                X, Y, dtype=dtype, force_all_finite=force_all_finite
+            )
+
+        # precompute data-derived metric params
+        params = _precompute_metric_params(X, Y, metric=metric, **kwds)
+        kwds.update(**params)
+
+        if effective_n_jobs(n_jobs) == 1 and X is Y:
+            return distance.squareform(distance.pdist(X, metric=metric, **kwds))
+        func = partial(distance.cdist, metric=metric, **kwds)
+
+    return _parallel_pairwise(X, Y, func, n_jobs, **kwds)
+
+
+# logic to deprecate `force_all_finite` from sklearn:
+# it was renamed to `ensure_all_finite` since 1.6 and will be removed in 1.8
+if sklearn_check_version("1.3"):
+    pairwise_distances_parameters = {
+        "X": ["array-like", "sparse matrix"],
+        "Y": ["array-like", "sparse matrix", None],
+        "metric": [StrOptions(set(_VALID_METRICS) | {"precomputed"}), callable],
+        "n_jobs": [Integral, None],
+        "force_all_finite": [
+            "boolean",
+            StrOptions({"allow-nan"}),
+            Hidden(StrOptions({"deprecated"})),
+        ],
+        "ensure_all_finite": [
+            "boolean",
+            StrOptions({"allow-nan"}),
+            Hidden(None),
+        ],
+    }
+    if sklearn_check_version("1.6"):
+        if sklearn_check_version("1.8"):
+            del pairwise_distances_parameters["force_all_finite"]
+
+            def pairwise_distances(
+                X,
+                Y=None,
+                metric="euclidean",
+                *,
+                n_jobs=None,
+                ensure_all_finite=True,
+                **kwds,
+            ):
+                return _pairwise_distances(
+                    X,
+                    Y,
+                    metric,
+                    n_jobs=n_jobs,
+                    force_all_finite=ensure_all_finite,
+                    **kwds,
+                )
+
+        else:
+            from sklearn.utils.deprecation import _deprecate_force_all_finite
+
+            def pairwise_distances(
+                X,
+                Y=None,
+                metric="euclidean",
+                *,
+                n_jobs=None,
+                force_all_finite="deprecated",
+                ensure_all_finite=None,
+                **kwds,
+            ):
+                force_all_finite = _deprecate_force_all_finite(
+                    force_all_finite, ensure_all_finite
+                )
+                return _pairwise_distances(
+                    X, Y, metric, n_jobs=n_jobs, force_all_finite=force_all_finite, **kwds
+                )
+
+    else:
+        del pairwise_distances_parameters["ensure_all_finite"]
+
+        def pairwise_distances(
+            X,
+            Y=None,
+            metric="euclidean",
+            *,
+            n_jobs=None,
+            force_all_finite=True,
+            **kwds,
+        ):
+            return _pairwise_distances(
+                X,
+                Y,
+                metric,
+                n_jobs=n_jobs,
+                force_all_finite=force_all_finite,
+                **kwds,
+            )
+
+    pairwise_distances = validate_params(
+        pairwise_distances_parameters,
+        prefer_skip_nested_validation=True,
+    )(pairwise_distances)
+else:
+    pairwise_distances = _pairwise_distances
+pairwise_distances.__doc__ = pairwise_distances_original.__doc__

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

@@ -0,0 +1,210 @@
+# ==============================================================================
+# Copyright 2020 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 collections.abc import Sequence
+from functools import partial
+
+import numpy as np
+from scipy import sparse as sp
+from sklearn.metrics._base import _average_binary_score
+from sklearn.metrics._ranking import _binary_roc_auc_score
+from sklearn.metrics._ranking import _multiclass_roc_auc_score as multiclass_roc_auc_score
+from sklearn.preprocessing import label_binarize
+from sklearn.utils import check_array
+from sklearn.utils.multiclass import is_multilabel
+
+import daal4py as d4p
+
+from .._utils import PatchingConditionsChain, get_patch_message, sklearn_check_version
+from ..utils.validation import _assert_all_finite
+
+if sklearn_check_version("1.3"):
+    from sklearn.utils._param_validation import (
+        Interval,
+        Real,
+        StrOptions,
+        validate_params,
+    )
+
+try:
+    import pandas as pd
+
+    pandas_is_imported = True
+except ImportError:
+    pandas_is_imported = False
+
+
+def _daal_type_of_target(y):
+    valid = (
+        isinstance(y, Sequence) or sp.isspmatrix(y) or hasattr(y, "__array__")
+    ) and not isinstance(y, str)
+
+    if not valid:
+        raise ValueError(
+            "Expected array-like (array or non-string sequence), " "got %r" % y
+        )
+
+    sparse_pandas = y.__class__.__name__ in ["SparseSeries", "SparseArray"]
+    if sparse_pandas:
+        raise ValueError("y cannot be class 'SparseSeries' or 'SparseArray'")
+
+    if is_multilabel(y):
+        return "multilabel-indicator"
+
+    try:
+        y = np.asarray(y)
+    except ValueError:
+        # Known to fail in numpy 1.3 for array of arrays
+        return "unknown"
+
+    # The old sequence of sequences format
+    try:
+        if (
+            not hasattr(y[0], "__array__")
+            and isinstance(y[0], Sequence)
+            and not isinstance(y[0], str)
+        ):
+            raise ValueError(
+                "You appear to be using a legacy multi-label data"
+                " representation. Sequence of sequences are no"
+                " longer supported; use a binary array or sparse"
+                " matrix instead - the MultiLabelBinarizer"
+                " transformer can convert to this format."
+            )
+    except IndexError:
+        pass
+
+    # Invalid inputs
+    if y.ndim > 2 or (
+        y.dtype == object and len(y) != 0 and not isinstance(y.flat[0], str)
+    ):
+        return "unknown"  # [[[1, 2]]] or [obj_1] and not ["label_1"]
+
+    if y.ndim == 2 and y.shape[1] == 0:
+        return "unknown"  # [[]]
+
+    if y.ndim == 2 and y.shape[1] > 1:
+        suffix = "-multioutput"  # [[1, 2], [1, 2]]
+    else:
+        suffix = ""  # [1, 2, 3] or [[1], [2], [3]]
+
+    # check float and contains non-integer float values
+    if y.dtype.kind == "f" and np.any(y != y.astype(int)):
+        # [.1, .2, 3] or [[.1, .2, 3]] or [[1., .2]] and not [1., 2., 3.]
+        _assert_all_finite(y)
+        return "continuous" + suffix
+
+    unique = np.sort(pd.unique(y.ravel())) if pandas_is_imported else np.unique(y)
+
+    if (len(unique) > 2) or (y.ndim >= 2 and len(y[0]) > 1):
+        # [1, 2, 3] or [[1., 2., 3]] or [[1, 2]]
+        result = ("multiclass" + suffix, None)
+    else:
+        result = ("binary", unique)  # [1, 2] or [["a"], ["b"]]
+    return result
+
+
+def roc_auc_score(
+    y_true,
+    y_score,
+    *,
+    average="macro",
+    sample_weight=None,
+    max_fpr=None,
+    multi_class="raise",
+    labels=None,
+):
+    y_type = _daal_type_of_target(y_true)
+    y_true = check_array(y_true, ensure_2d=False, dtype=None)
+    y_score = check_array(y_score, ensure_2d=False)
+
+    _patching_status = PatchingConditionsChain("sklearn.metrics.roc_auc_score")
+    _dal_ready = _patching_status.and_conditions(
+        [
+            (
+                y_type[0] == "binary"
+                and not (y_score.ndim == 2 and y_score.shape[1] > 2),
+                "y_true type is not one-dimensional binary.",
+            )
+        ]
+    )
+
+    _patching_status.write_log()
+    if y_type[0] == "multiclass" or (
+        y_type[0] == "binary" and y_score.ndim == 2 and y_score.shape[1] > 2
+    ):
+        # do not support partial ROC computation for multiclass
+        if max_fpr is not None and max_fpr != 1.0:
+            raise ValueError(
+                "Partial AUC computation not available in "
+                "multiclass setting, 'max_fpr' must be"
+                " set to `None`, received `max_fpr={0}` "
+                "instead".format(max_fpr)
+            )
+        if multi_class == "raise":
+            raise ValueError("multi_class must be in ('ovo', 'ovr')")
+
+        return multiclass_roc_auc_score(
+            y_true, y_score, labels, multi_class, average, sample_weight
+        )
+
+    if y_type[0] == "binary":
+        labels = y_type[1]
+        _dal_ready = _patching_status.and_conditions(
+            [
+                (len(labels) == 2, "Number of unique labels is not equal to 2."),
+                (max_fpr is None, "Maximum false-positive rate is not supported."),
+                (sample_weight is None, "Sample weights are not supported."),
+            ]
+        )
+        if _dal_ready:
+            if not np.array_equal(labels, [0, 1]) or labels.dtype == bool:
+                y_true = label_binarize(y_true, classes=labels)[:, 0]
+                if hasattr(y_score, "dtype") and y_score.dtype == bool:
+                    y_score = label_binarize(y_score, classes=labels)[:, 0]
+            result = d4p.daal_roc_auc_score(y_true.reshape(-1, 1), y_score.reshape(-1, 1))
+            if result != -1:
+                return result
+            logging.info(
+                "sklearn.metrics.roc_auc_score: "
+                + get_patch_message("sklearn_after_daal")
+            )
+        # return to sklearn implementation
+        y_true = label_binarize(y_true, classes=labels)[:, 0]
+
+    return _average_binary_score(
+        partial(_binary_roc_auc_score, max_fpr=max_fpr),
+        y_true,
+        y_score,
+        average,
+        sample_weight=sample_weight,
+    )
+
+
+if sklearn_check_version("1.3"):
+    roc_auc_score = validate_params(
+        {
+            "y_true": ["array-like"],
+            "y_score": ["array-like"],
+            "average": [StrOptions({"micro", "macro", "samples", "weighted"}), None],
+            "sample_weight": ["array-like", None],
+            "max_fpr": [Interval(Real, 0.0, 1, closed="right"), None],
+            "multi_class": [StrOptions({"raise", "ovr", "ovo"})],
+            "labels": ["array-like", None],
+        },
+        prefer_skip_nested_validation=True,
+    )(roc_auc_score)

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

@@ -0,0 +1,19 @@
+# ===============================================================================
+# 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 ._split import train_test_split
+
+__all__ = ["train_test_split"]