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

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

@@ -1,257 +0,0 @@
-# ==============================================================================
-# Copyright 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-
-import logging
-import sys
-from collections.abc import Iterable
-from functools import wraps
-
-import numpy as np
-
-try:
-    from dpctl import SyclQueue
-    from dpctl.memory import MemoryUSMDevice, as_usm_memory
-    from dpctl.tensor import usm_ndarray
-
-    dpctl_available = True
-except ImportError:
-    dpctl_available = False
-
-try:
-    import dpnp
-
-    dpnp_available = True
-except ImportError:
-    dpnp_available = False
-
-from ._config import get_config
-from ._utils import get_patch_message
-
-oneapi_is_available = "daal4py.oneapi" in sys.modules
-if oneapi_is_available:
-    from daal4py.oneapi import _get_device_name_sycl_ctxt, _get_sycl_ctxt_params
-
-
-class DummySyclQueue:
-    """This class is designed to act like dpctl.SyclQueue
-    to allow device dispatching in scenarios when dpctl is not available"""
-
-    class DummySyclDevice:
-        def __init__(self, filter_string):
-            self._filter_string = filter_string
-            self.is_cpu = "cpu" in filter_string
-            self.is_gpu = "gpu" in filter_string
-            # TODO: check for possibility of fp64 support
-            # on other devices in this dummy class
-            self.has_aspect_fp64 = self.is_cpu
-
-            if not (self.is_cpu):
-                logging.warning(
-                    "Device support is limited. "
-                    "Please install dpctl for full experience"
-                )
-
-        def get_filter_string(self):
-            return self._filter_string
-
-    def __init__(self, filter_string):
-        self.sycl_device = self.DummySyclDevice(filter_string)
-
-
-def _get_device_info_from_daal4py():
-    if oneapi_is_available:
-        return _get_device_name_sycl_ctxt(), _get_sycl_ctxt_params()
-    return None, dict()
-
-
-def _get_global_queue():
-    target = get_config()["target_offload"]
-    d4p_target, _ = _get_device_info_from_daal4py()
-    if d4p_target == "host":
-        d4p_target = "cpu"
-
-    QueueClass = DummySyclQueue if not dpctl_available else SyclQueue
-
-    if target != "auto":
-        if d4p_target is not None and d4p_target != target:
-            if not isinstance(target, str):
-                if d4p_target not in target.sycl_device.get_filter_string():
-                    raise RuntimeError(
-                        "Cannot use target offload option "
-                        "inside daal4py.oneapi.sycl_context"
-                    )
-            else:
-                raise RuntimeError(
-                    "Cannot use target offload option "
-                    "inside daal4py.oneapi.sycl_context"
-                )
-        if isinstance(target, QueueClass):
-            return target
-        return QueueClass(target)
-    if d4p_target is not None:
-        return QueueClass(d4p_target)
-    return None
-
-
-def _transfer_to_host(queue, *data):
-    has_usm_data, has_host_data = False, False
-
-    host_data = []
-    for item in data:
-        usm_iface = getattr(item, "__sycl_usm_array_interface__", None)
-        if usm_iface is not None:
-            if not dpctl_available:
-                raise RuntimeError(
-                    "dpctl need to be installed to work "
-                    "with __sycl_usm_array_interface__"
-                )
-            if queue is not None:
-                if queue.sycl_device != usm_iface["syclobj"].sycl_device:
-                    raise RuntimeError(
-                        "Input data shall be located " "on single target device"
-                    )
-            else:
-                queue = usm_iface["syclobj"]
-
-            buffer = as_usm_memory(item).copy_to_host()
-            order = "C"
-            if usm_iface["strides"] is not None:
-                if usm_iface["strides"][0] < usm_iface["strides"][1]:
-                    order = "F"
-            item = np.ndarray(
-                shape=usm_iface["shape"],
-                dtype=usm_iface["typestr"],
-                buffer=buffer,
-                order=order,
-            )
-            has_usm_data = True
-        else:
-            has_host_data = True
-
-        mismatch_host_item = usm_iface is None and item is not None and has_usm_data
-        mismatch_usm_item = usm_iface is not None and has_host_data
-
-        if mismatch_host_item or mismatch_usm_item:
-            raise RuntimeError("Input data shall be located on single target device")
-
-        host_data.append(item)
-    return queue, host_data
-
-
-def _get_backend(obj, queue, method_name, *data):
-    cpu_device = queue is None or queue.sycl_device.is_cpu
-    gpu_device = queue is not None and queue.sycl_device.is_gpu
-
-    if cpu_device:
-        patching_status = obj._onedal_cpu_supported(method_name, *data)
-        if patching_status.get_status():
-            return "onedal", queue, patching_status
-        else:
-            return "sklearn", None, patching_status
-
-    _, d4p_options = _get_device_info_from_daal4py()
-    allow_fallback_to_host = get_config()["allow_fallback_to_host"] or d4p_options.get(
-        "host_offload_on_fail", False
-    )
-
-    if gpu_device:
-        patching_status = obj._onedal_gpu_supported(method_name, *data)
-        if patching_status.get_status():
-            return "onedal", queue, patching_status
-        else:
-            if allow_fallback_to_host:
-                patching_status = obj._onedal_cpu_supported(method_name, *data)
-                if patching_status.get_status():
-                    return "onedal", None, patching_status
-                else:
-                    return "sklearn", None, patching_status
-            else:
-                return "sklearn", None, patching_status
-
-    raise RuntimeError("Device support is not implemented")
-
-
-def dispatch(obj, method_name, branches, *args, **kwargs):
-    q = _get_global_queue()
-    q, hostargs = _transfer_to_host(q, *args)
-    q, hostvalues = _transfer_to_host(q, *kwargs.values())
-    hostkwargs = dict(zip(kwargs.keys(), hostvalues))
-
-    backend, q, patching_status = _get_backend(obj, q, method_name, *hostargs)
-
-    if backend == "onedal":
-        patching_status.write_log(queue=q)
-        return branches[backend](obj, *hostargs, **hostkwargs, queue=q)
-    if backend == "sklearn":
-        patching_status.write_log()
-        return branches[backend](obj, *hostargs, **hostkwargs)
-    raise RuntimeError(
-        f"Undefined backend {backend} in " f"{obj.__class__.__name__}.{method_name}"
-    )
-
-
-def _copy_to_usm(queue, array):
-    if not dpctl_available:
-        raise RuntimeError(
-            "dpctl need to be installed to work " "with __sycl_usm_array_interface__"
-        )
-
-    if hasattr(array, "__array__"):
-
-        try:
-            mem = MemoryUSMDevice(array.nbytes, queue=queue)
-            mem.copy_from_host(array.tobytes())
-            return usm_ndarray(array.shape, array.dtype, buffer=mem)
-        except ValueError as e:
-            # ValueError will raise if device does not support the dtype
-            # retry with float32 (needed for fp16 and fp64 support issues)
-            # try again as float32, if it is a float32 just raise the error.
-            if array.dtype == np.float32:
-                raise e
-            return _copy_to_usm(queue, array.astype(np.float32))
-    else:
-        if isinstance(array, Iterable):
-            array = [_copy_to_usm(queue, i) for i in array]
-        return array
-
-
-if dpnp_available:
-
-    def _convert_to_dpnp(array):
-        if isinstance(array, usm_ndarray):
-            return dpnp.array(array, copy=False)
-        elif isinstance(array, Iterable):
-            for i in range(len(array)):
-                array[i] = _convert_to_dpnp(array[i])
-        return array
-
-
-def wrap_output_data(func):
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        data = (*args, *kwargs.values())
-        if len(data) == 0:
-            usm_iface = None
-        else:
-            usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
-        result = func(self, *args, **kwargs)
-        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
-
-    return wrapper

scikit_learn_intelex-2024.5.0.data/data/Lib/site-packages/sklearnex/basic_statistics/basic_statistics.py

@@ -1,17 +0,0 @@
-# ==============================================================================
-# Copyright 2023 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 onedal.basic_statistics import BasicStatistics

scikit_learn_intelex-2024.5.0.data/data/Lib/site-packages/sklearnex/svm/_common.py

@@ -1,185 +0,0 @@
-# ==============================================================================
-# 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 abc import ABC
-
-import numpy as np
-from sklearn.calibration import CalibratedClassifierCV
-from sklearn.model_selection import StratifiedKFold
-from sklearn.preprocessing import LabelEncoder
-
-from daal4py.sklearn._utils import sklearn_check_version
-from onedal.utils import _column_or_1d
-
-from .._utils import PatchingConditionsChain
-
-
-def get_dual_coef(self):
-    return self.dual_coef_
-
-
-def set_dual_coef(self, value):
-    self.dual_coef_ = value
-    if hasattr(self, "_onedal_estimator"):
-        self._onedal_estimator.dual_coef_ = value
-        if not self._is_in_fit:
-            del self._onedal_estimator._onedal_model
-
-
-def get_intercept(self):
-    return self._intercept_
-
-
-def set_intercept(self, value):
-    self._intercept_ = value
-    if hasattr(self, "_onedal_estimator"):
-        self._onedal_estimator.intercept_ = value
-        if not self._is_in_fit:
-            del self._onedal_estimator._onedal_model
-
-
-class BaseSVM(ABC):
-    def _onedal_gpu_supported(self, method_name, *data):
-        patching_status = PatchingConditionsChain(f"sklearn.{method_name}")
-        patching_status.and_conditions([(False, "GPU offloading is not supported.")])
-        return patching_status
-
-    def _onedal_cpu_supported(self, method_name, *data):
-        class_name = self.__class__.__name__
-        patching_status = PatchingConditionsChain(
-            f"sklearn.svm.{class_name}.{method_name}"
-        )
-        if method_name == "fit":
-            patching_status.and_conditions(
-                [
-                    (
-                        self.kernel in ["linear", "rbf", "poly", "sigmoid"],
-                        f'Kernel is "{self.kernel}" while '
-                        '"linear", "rbf", "poly" and "sigmoid" are only supported.',
-                    )
-                ]
-            )
-            return patching_status
-        inference_methods = (
-            ["predict"]
-            if class_name.endswith("R")
-            else ["predict", "predict_proba", "decision_function", "score"]
-        )
-        if method_name in inference_methods:
-            patching_status.and_conditions(
-                [(hasattr(self, "_onedal_estimator"), "oneDAL model was not trained.")]
-            )
-            return patching_status
-        raise RuntimeError(f"Unknown method {method_name} in {class_name}")
-
-
-class BaseSVC(BaseSVM):
-    def _compute_balanced_class_weight(self, y):
-        y_ = _column_or_1d(y)
-        classes, _ = np.unique(y_, return_inverse=True)
-
-        le = LabelEncoder()
-        y_ind = le.fit_transform(y_)
-        if not all(np.in1d(classes, le.classes_)):
-            raise ValueError("classes should have valid labels that are in y")
-
-        recip_freq = len(y_) / (len(le.classes_) * np.bincount(y_ind).astype(np.float64))
-        return recip_freq[le.transform(classes)]
-
-    def _fit_proba(self, X, y, sample_weight=None, queue=None):
-        params = self.get_params()
-        params["probability"] = False
-        params["decision_function_shape"] = "ovr"
-        clf_base = self.__class__(**params)
-
-        try:
-            n_splits = 5
-            n_jobs = n_splits if queue is None or queue.sycl_device.is_cpu else 1
-            cv = StratifiedKFold(
-                n_splits=n_splits, shuffle=True, random_state=self.random_state
-            )
-            self.clf_prob = CalibratedClassifierCV(
-                clf_base, ensemble=False, cv=cv, method="sigmoid", n_jobs=n_jobs
-            )
-            self.clf_prob.fit(X, y, sample_weight)
-        except ValueError:
-            clf_base = clf_base.fit(X, y, sample_weight)
-            self.clf_prob = CalibratedClassifierCV(
-                clf_base, cv="prefit", method="sigmoid"
-            )
-            self.clf_prob.fit(X, y, sample_weight)
-
-    def _save_attributes(self):
-        self.support_vectors_ = self._onedal_estimator.support_vectors_
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
-        self.fit_status_ = 0
-        self.dual_coef_ = self._onedal_estimator.dual_coef_
-        self.shape_fit_ = self._onedal_estimator.class_weight_
-        self.classes_ = self._onedal_estimator.classes_
-        self.class_weight_ = self._onedal_estimator.class_weight_
-        self.support_ = self._onedal_estimator.support_
-
-        self._intercept_ = self._onedal_estimator.intercept_
-        self._n_support = self._onedal_estimator._n_support
-        self._sparse = False
-        self._gamma = self._onedal_estimator._gamma
-        if self.probability:
-            length = int(len(self.classes_) * (len(self.classes_) - 1) / 2)
-            self._probA = np.zeros(length)
-            self._probB = np.zeros(length)
-        else:
-            self._probA = np.empty(0)
-            self._probB = np.empty(0)
-
-        self._dual_coef_ = property(get_dual_coef, set_dual_coef)
-        self.intercept_ = property(get_intercept, set_intercept)
-
-        self._is_in_fit = True
-        self._dual_coef_ = self.dual_coef_
-        self.intercept_ = self._intercept_
-        self._is_in_fit = False
-
-        if sklearn_check_version("1.1"):
-            length = int(len(self.classes_) * (len(self.classes_) - 1) / 2)
-            self.n_iter_ = np.full((length,), self._onedal_estimator.n_iter_)
-
-
-class BaseSVR(BaseSVM):
-    def _save_attributes(self):
-        self.support_vectors_ = self._onedal_estimator.support_vectors_
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
-        self.fit_status_ = 0
-        self.dual_coef_ = self._onedal_estimator.dual_coef_
-        self.shape_fit_ = self._onedal_estimator.shape_fit_
-        self.support_ = self._onedal_estimator.support_
-
-        self._intercept_ = self._onedal_estimator.intercept_
-        self._n_support = [self.support_vectors_.shape[0]]
-        self._sparse = False
-        self._gamma = self._onedal_estimator._gamma
-        self._probA = None
-        self._probB = None
-
-        self._dual_coef_ = property(get_dual_coef, set_dual_coef)
-        self.intercept_ = property(get_intercept, set_intercept)
-
-        self._is_in_fit = True
-        self._dual_coef_ = self.dual_coef_
-        self.intercept_ = self._intercept_
-        self._is_in_fit = False
-
-        if sklearn_check_version("1.1"):
-            self.n_iter_ = self._onedal_estimator.n_iter_

scikit_learn_intelex-2024.5.0.data/data/Lib/site-packages/sklearnex/tests/_utils.py

@@ -1,173 +0,0 @@
-# ==============================================================================
-# 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.
-# ==============================================================================
-
-from inspect import isclass
-
-import numpy as np
-from sklearn import clone
-from sklearn.base import (
-    BaseEstimator,
-    ClassifierMixin,
-    ClusterMixin,
-    OutlierMixin,
-    RegressorMixin,
-    TransformerMixin,
-)
-from sklearn.datasets import load_diabetes, load_iris
-from sklearn.neighbors._base import KNeighborsMixin
-
-from onedal.tests.utils._dataframes_support import _convert_to_dataframe
-from sklearnex import get_patch_map, patch_sklearn, sklearn_is_patched, unpatch_sklearn
-from sklearnex.linear_model import LogisticRegression
-from sklearnex.neighbors import (
-    KNeighborsClassifier,
-    KNeighborsRegressor,
-    LocalOutlierFactor,
-    NearestNeighbors,
-)
-from sklearnex.svm import SVC, NuSVC
-
-
-def _load_all_models(with_sklearnex=True, estimator=True):
-    # insure that patch state is correct as dictated by patch_sklearn boolean
-    # and return it to the previous state no matter what occurs.
-    already_patched_map = sklearn_is_patched(return_map=True)
-    already_patched = any(already_patched_map.values())
-    try:
-        if with_sklearnex:
-            patch_sklearn()
-        elif already_patched:
-            unpatch_sklearn()
-
-        models = {}
-        for patch_infos in get_patch_map().values():
-            candidate = getattr(patch_infos[0][0][0], patch_infos[0][0][1], None)
-            if candidate is not None and isclass(candidate) == estimator:
-                if not estimator or issubclass(candidate, BaseEstimator):
-                    models[patch_infos[0][0][1]] = candidate
-    finally:
-        if with_sklearnex:
-            unpatch_sklearn()
-        # both branches are now in an unpatched state, repatch as necessary
-        if already_patched:
-            patch_sklearn(name=[i for i in already_patched_map if already_patched_map[i]])
-
-    return models
-
-
-PATCHED_MODELS = _load_all_models(with_sklearnex=True)
-UNPATCHED_MODELS = _load_all_models(with_sklearnex=False)
-
-PATCHED_FUNCTIONS = _load_all_models(with_sklearnex=True, estimator=False)
-UNPATCHED_FUNCTIONS = _load_all_models(with_sklearnex=False, estimator=False)
-
-mixin_map = [
-    [
-        ClassifierMixin,
-        ["decision_function", "predict", "predict_proba", "predict_log_proba", "score"],
-        "classification",
-    ],
-    [RegressorMixin, ["predict", "score"], "regression"],
-    [ClusterMixin, ["fit_predict"], "classification"],
-    [TransformerMixin, ["fit_transform", "transform", "score"], "classification"],
-    [OutlierMixin, ["fit_predict", "predict"], "classification"],
-    [KNeighborsMixin, ["kneighbors"], None],
-]
-
-
-class _sklearn_clone_dict(dict):
-
-    def __getitem__(self, key):
-        return clone(super().__getitem__(key))
-
-
-SPECIAL_INSTANCES = _sklearn_clone_dict(
-    {
-        str(i): i
-        for i in [
-            LocalOutlierFactor(novelty=True),
-            SVC(probability=True),
-            NuSVC(probability=True),
-            KNeighborsClassifier(algorithm="brute"),
-            KNeighborsRegressor(algorithm="brute"),
-            NearestNeighbors(algorithm="brute"),
-            LogisticRegression(solver="newton-cg"),
-        ]
-    }
-)
-
-
-def gen_models_info(algorithms):
-    output = []
-    for i in algorithms:
-
-        if i in PATCHED_MODELS:
-            est = PATCHED_MODELS[i]
-        elif i in SPECIAL_INSTANCES:
-            est = SPECIAL_INSTANCES[i].__class__
-        else:
-            raise KeyError(f"Unrecognized sklearnex estimator: {i}")
-
-        methods = set()
-        candidates = set(
-            [i for i in dir(est) if not i.startswith("_") and not i.endswith("_")]
-        )
-
-        for mixin, method, _ in mixin_map:
-            if issubclass(est, mixin):
-                methods |= candidates & set(method)
-
-        output += [[i, j] for j in methods] if methods else [[i, None]]
-
-    # In the case that no methods are available, set method to None.
-    # This will allow estimators without mixins to still test the fit
-    # method in various tests.
-    return output
-
-
-def gen_dataset(estimator, queue=None, target_df=None, dtype=np.float64):
-    dataset = None
-    name = estimator.__class__.__name__
-    est = PATCHED_MODELS[name]
-    for mixin, _, data in mixin_map:
-        if issubclass(est, mixin) and data is not None:
-            dataset = data
-    # load data
-    if dataset == "classification" or dataset is None:
-        X, y = load_iris(return_X_y=True)
-    elif dataset == "regression":
-        X, y = load_diabetes(return_X_y=True)
-    else:
-        raise ValueError("Unknown dataset type")
-
-    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=target_df, dtype=dtype)
-    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=target_df, dtype=dtype)
-    return X, y
-
-
-DTYPES = [
-    np.int8,
-    np.int16,
-    np.int32,
-    np.int64,
-    np.float16,
-    np.float32,
-    np.float64,
-    np.uint8,
-    np.uint16,
-    np.uint32,
-    np.uint64,
-]