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

scikit_learn_intelex-2025.0.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.0.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"]

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/daal4py/sklearn/model_selection/_split.py

@@ -0,0 +1,309 @@
+# ===============================================================================
+# 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 platform
+
+import numpy as np
+from sklearn.model_selection import ShuffleSplit, StratifiedShuffleSplit
+from sklearn.model_selection._split import _validate_shuffle_split
+from sklearn.utils import indexable
+from sklearn.utils.validation import _num_samples
+
+import daal4py as d4p
+from daal4py.sklearn._utils import PatchingConditionsChain
+
+from .._utils import sklearn_check_version
+
+try:
+    from sklearn.utils import _safe_indexing as safe_indexing
+except ImportError:
+    from sklearn.utils import safe_indexing
+
+try:
+    import mkl_random
+
+    mkl_random_is_imported = True
+except (ImportError, ModuleNotFoundError):
+    mkl_random_is_imported = False
+
+try:
+    import pandas as pd
+
+    pandas_is_imported = True
+except (ImportError, ModuleNotFoundError):
+    pandas_is_imported = False
+
+if sklearn_check_version("1.3"):
+    import numbers
+
+    from sklearn.utils._param_validation import Interval, RealNotInt, validate_params
+
+
+def get_dtypes(data):
+    if hasattr(data, "dtype"):
+        return [data.dtype]
+    if hasattr(data, "dtypes"):
+        return list(data.dtypes)
+    if hasattr(data, "values"):
+        return [data.values.dtype]
+    return None
+
+
+def train_test_split(*arrays, **options):
+    n_arrays = len(arrays)
+    if n_arrays == 0:
+        raise ValueError("At least one array required as input")
+    test_size = options.pop("test_size", None)
+    train_size = options.pop("train_size", None)
+    random_state = options.pop("random_state", None)
+    stratify = options.pop("stratify", None)
+    shuffle = options.pop("shuffle", True)
+    rng = options.pop("rng", "OPTIMIZED_MT19937")
+
+    available_rngs = [
+        "default",
+        "MT19937",
+        "SFMT19937",
+        "MT2203",
+        "R250",
+        "WH",
+        "MCG31",
+        "MCG59",
+        "MRG32K3A",
+        "PHILOX4X32X10",
+        "NONDETERM",
+        "OPTIMIZED_MT19937",
+    ]
+    if rng not in available_rngs:
+        raise ValueError(
+            "Wrong random numbers generator is chosen. "
+            "Available generators: %s" % str(available_rngs)[1:-1]
+        )
+
+    if options:
+        raise TypeError("Invalid parameters passed: %s" % str(options))
+
+    arrays = indexable(*arrays)
+
+    n_samples = _num_samples(arrays[0])
+    n_train, n_test = _validate_shuffle_split(
+        n_samples, test_size, train_size, default_test_size=0.25
+    )
+    if shuffle is False:
+        if stratify is not None:
+            raise ValueError(
+                "Stratified train/test split is not implemented for shuffle=False"
+            )
+
+        train = np.arange(n_train)
+        test = np.arange(n_train, n_train + n_test)
+    else:
+        if stratify is not None:
+            cv = StratifiedShuffleSplit(
+                test_size=n_test, train_size=n_train, random_state=random_state
+            )
+            train, test = next(cv.split(X=arrays[0], y=stratify))
+        else:
+            if (
+                mkl_random_is_imported
+                and rng not in ["default", "OPTIMIZED_MT19937"]
+                and (isinstance(random_state, int) or random_state is None)
+            ):
+                random_state = mkl_random.RandomState(random_state, rng)
+                indexes = random_state.permutation(n_samples)
+                test, train = indexes[:n_test], indexes[n_test : (n_test + n_train)]
+            elif (
+                rng == "OPTIMIZED_MT19937"
+                and (isinstance(random_state, int) or random_state is None)
+                and platform.system() != "Windows"
+            ):
+                indexes = np.empty(
+                    shape=(n_samples,),
+                    dtype=np.int64 if n_train + n_test > 2**31 - 1 else np.int32,
+                )
+                random_state = np.random.RandomState(random_state)
+                random_state = random_state.get_state()[1]
+                d4p.daal_generate_shuffled_indices([indexes], [random_state])
+                test, train = indexes[:n_test], indexes[n_test : (n_test + n_train)]
+            else:
+                cv = ShuffleSplit(
+                    test_size=n_test, train_size=n_train, random_state=random_state
+                )
+                train, test = next(cv.split(X=arrays[0], y=stratify))
+
+    res = []
+    for arr in arrays:
+        _patching_status = PatchingConditionsChain(
+            "sklearn.model_selection.train_test_split"
+        )
+
+        # input format check
+        _patching_status.and_conditions(
+            [(isinstance(arr, np.ndarray), "The input is not a np.ndarray object.")]
+        )
+        if pandas_is_imported:
+            _patching_status.or_conditions(
+                [
+                    (
+                        isinstance(arr, pd.core.frame.DataFrame),
+                        "The input is not a pd.DataFrame object.",
+                    ),
+                    (
+                        isinstance(arr, pd.core.series.Series),
+                        "The input is not a pd.Series object.",
+                    ),
+                ],
+                conditions_merging=any,
+            )
+
+        # dimensions check
+        _dal_ready = _patching_status.and_conditions(
+            [(hasattr(arr, "ndim"), "The input does not have 'ndim' attribute.")]
+        )
+        if hasattr(arr, "ndim"):
+            _patching_status.and_conditions(
+                [(arr.ndim <= 2, "The input has more than 2 dimensions.")]
+            )
+
+        # data types check
+        dtypes = get_dtypes(arr)
+        _dal_ready = _patching_status.and_conditions(
+            [(dtypes is not None, "Unable to parse input data types.")]
+        )
+        if dtypes is not None:
+            incorrect_dtype = None
+            for i, dtype in enumerate(dtypes):
+                if str(dtype) not in ["float32", "float64"] and "int" not in str(dtype):
+                    incorrect_dtype = str(dtype)
+                    break
+            _dal_ready = _patching_status.and_conditions(
+                [
+                    (
+                        incorrect_dtype is None,
+                        f"Input has incorrect data type '{incorrect_dtype}'. "
+                        "Only integer and 32/64-bits floating point types are supported.",
+                    )
+                ]
+            )
+
+        _patching_status.write_log()
+        if not _dal_ready:
+            res.append(safe_indexing(arr, train))
+            res.append(safe_indexing(arr, test))
+        else:
+            if len(arr.shape) == 2:
+                n_cols = arr.shape[1]
+                reshape_later = False
+            else:
+                n_cols = 1
+                reshape_later = True
+
+            arr_copy = d4p.get_data(arr)
+            if not isinstance(arr_copy, list):
+                arr_copy = arr_copy.reshape(
+                    (arr_copy.shape[0], n_cols),
+                    order="A",
+                )
+            if isinstance(arr_copy, np.ndarray):
+                order = "C" if arr_copy.flags["C_CONTIGUOUS"] else "F"
+                train_arr = np.empty(
+                    shape=(n_train, n_cols),
+                    dtype=arr_copy.dtype,
+                    order=order,
+                )
+                test_arr = np.empty(
+                    shape=(n_test, n_cols),
+                    dtype=arr_copy.dtype,
+                    order=order,
+                )
+                d4p.daal_train_test_split(arr_copy, train_arr, test_arr, [train], [test])
+                if reshape_later:
+                    train_arr, test_arr = train_arr.reshape((n_train,)), test_arr.reshape(
+                        (n_test,)
+                    )
+            elif isinstance(arr_copy, list):
+                train_arr = [
+                    np.empty(
+                        shape=(n_train,),
+                        dtype=el.dtype,
+                        order="C" if el.flags["C_CONTIGUOUS"] else "F",
+                    )
+                    for el in arr_copy
+                ]
+                test_arr = [
+                    np.empty(
+                        shape=(n_test,),
+                        dtype=el.dtype,
+                        order="C" if el.flags["C_CONTIGUOUS"] else "F",
+                    )
+                    for el in arr_copy
+                ]
+                d4p.daal_train_test_split(arr_copy, train_arr, test_arr, [train], [test])
+                train_arr = {col: train_arr[i] for i, col in enumerate(arr.columns)}
+                test_arr = {col: test_arr[i] for i, col in enumerate(arr.columns)}
+            else:
+                raise ValueError("Array can't be converted to needed format")
+
+            if pandas_is_imported:
+                if isinstance(arr, pd.core.frame.DataFrame):
+                    train_arr, test_arr = pd.DataFrame(
+                        train_arr, columns=arr.columns
+                    ), pd.DataFrame(test_arr, columns=arr.columns)
+                if isinstance(arr, pd.core.series.Series):
+                    train_arr, test_arr = train_arr.reshape(n_train), test_arr.reshape(
+                        n_test
+                    )
+                    train_arr, test_arr = pd.Series(train_arr, name=arr.name), pd.Series(
+                        test_arr, name=arr.name
+                    )
+
+            if hasattr(arr, "index"):
+                train_arr.index = train
+                test_arr.index = test
+
+            if hasattr(arr, "columns"):
+                train_arr.columns = arr.columns
+                test_arr.columns = arr.columns
+
+            if hasattr(arr, "name"):
+                train_arr.name = arr.name
+                test_arr.name = arr.name
+
+            res.append(train_arr)
+            res.append(test_arr)
+
+    return res
+
+
+if sklearn_check_version("1.3"):
+    train_test_split = validate_params(
+        {
+            "test_size": [
+                Interval(RealNotInt, 0, 1, closed="neither"),
+                Interval(numbers.Integral, 1, None, closed="left"),
+                None,
+            ],
+            "train_size": [
+                Interval(RealNotInt, 0, 1, closed="neither"),
+                Interval(numbers.Integral, 1, None, closed="left"),
+                None,
+            ],
+            "random_state": ["random_state"],
+            "shuffle": ["boolean"],
+            "stratify": ["array-like", None],
+        },
+        prefer_skip_nested_validation=True,
+    )(train_test_split)

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/daal4py/sklearn/model_selection/tests/test_split.py

@@ -0,0 +1,56 @@
+# ===============================================================================
+# 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 sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split as skl_train_test_split
+
+from daal4py.sklearn._utils import daal_check_version
+from daal4py.sklearn.model_selection import train_test_split as d4p_train_test_split
+
+N_SAMPLES = [2**i + 1 for i in range(2, 17)]
+RANDOM_STATE = 777
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2021, "P", 400)),
+    reason="train_test_split has bugfix since 2021.4 release",
+)
+@pytest.mark.parametrize("n_samples", N_SAMPLES)
+def test_results_similarity(n_samples):
+    x, y = make_classification(
+        n_samples=n_samples, n_features=4, random_state=RANDOM_STATE
+    )
+    d4p_res = d4p_train_test_split(
+        x,
+        y,
+        test_size=n_samples // 2 - 1,
+        train_size=n_samples // 2 - 1,
+        random_state=RANDOM_STATE,
+    )
+    skl_res = skl_train_test_split(
+        x,
+        y,
+        test_size=n_samples // 2 - 1,
+        train_size=n_samples // 2 - 1,
+        random_state=RANDOM_STATE,
+    )
+
+    assert len(d4p_res) == len(skl_res), "train_test_splits have different output size"
+
+    for i, _ in enumerate(d4p_res):
+        assert np.all(d4p_res[i] == skl_res[i]), "train_test_splits have different output"