scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

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

@@ -1,250 +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()
-            item = np.ndarray(
-                shape=usm_iface["shape"], dtype=usm_iface["typestr"], buffer=buffer
-            )
-            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.4.0.data/data/Lib/site-packages/sklearnex/_utils.py

@@ -1,109 +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 os
-import sys
-import warnings
-
-from daal4py.sklearn._utils import (
-    PatchingConditionsChain as daal4py_PatchingConditionsChain,
-)
-from daal4py.sklearn._utils import daal_check_version
-
-
-class PatchingConditionsChain(daal4py_PatchingConditionsChain):
-    def get_status(self):
-        return self.patching_is_enabled
-
-    def write_log(self, queue=None):
-        if self.patching_is_enabled:
-            self.logger.info(
-                f"{self.scope_name}: {get_patch_message('onedal', queue=queue)}"
-            )
-        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)"
-            )
-            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 set_sklearn_ex_verbose():
-    log_level = os.environ.get("SKLEARNEX_VERBOSE")
-
-    logger = logging.getLogger("sklearnex")
-    logging_channel = logging.StreamHandler()
-    logging_formatter = logging.Formatter("%(levelname)s:%(name)s: %(message)s")
-    logging_channel.setFormatter(logging_formatter)
-    logger.addHandler(logging_channel)
-
-    try:
-        if log_level is not None:
-            logger.setLevel(log_level)
-    except Exception:
-        warnings.warn(
-            'Unknown level "{}" for logging.\n'
-            'Please, use one of "CRITICAL", "ERROR", '
-            '"WARNING", "INFO", "DEBUG".'.format(log_level)
-        )
-
-
-def get_patch_message(s, queue=None):
-    if s == "onedal":
-        message = "running accelerated version on "
-        if queue is not None:
-            if queue.sycl_device.is_gpu:
-                message += "GPU"
-            elif queue.sycl_device.is_cpu:
-                message += "CPU"
-            else:
-                raise RuntimeError("Unsupported device")
-        else:
-            message += "CPU"
-    elif s == "sklearn":
-        message = "fallback to original Scikit-learn"
-    elif s == "sklearn_after_onedal":
-        message = "failed to run accelerated version, fallback to original Scikit-learn"
-    else:
-        raise ValueError(
-            f"Invalid input - expected one of 'onedal','sklearn',"
-            f" 'sklearn_after_onedal', got {s}"
-        )
-    return message
-
-
-def get_sklearnex_version(rule):
-    return daal_check_version(rule)
-
-
-def register_hyperparameters(hyperparameters_map):
-    """Decorator for hyperparameters support in estimator class.
-    Adds `get_hyperparameters` method to class.
-    """
-
-    def wrap_class(estimator_class):
-        def get_hyperparameters(self, op):
-            return hyperparameters_map[op]
-
-        estimator_class.get_hyperparameters = get_hyperparameters
-        return estimator_class
-
-    return wrap_class

scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -1,17 +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 daal4py.sklearn.cluster import KMeans

scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/cluster/tests/test_kmeans.py

@@ -1,30 +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 numpy as np
-from numpy.testing import assert_allclose
-
-
-def test_sklearnex_import():
-    from sklearnex.cluster import KMeans
-
-    X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
-    kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
-    assert "daal4py" in kmeans.__module__
-
-    result = kmeans.predict([[0, 0], [12, 3]])
-    expected = np.array([1, 0], dtype=np.int32)
-    assert_allclose(expected, result)

scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -1,130 +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.
-# ===============================================================================
-
-import numpy as np
-from sklearn.utils import check_array, gen_batches
-
-from daal4py.sklearn._n_jobs_support import control_n_jobs
-from onedal._device_offload import support_usm_ndarray
-from onedal.covariance import (
-    IncrementalEmpiricalCovariance as onedal_IncrementalEmpiricalCovariance,
-)
-
-
-@control_n_jobs(decorated_methods=["partial_fit"])
-class IncrementalEmpiricalCovariance:
-    """
-    Incremental estimator for covariance.
-    Allows to compute empirical covariance estimated by maximum
-    likelihood method if data are splitted into batches.
-
-    Parameters
-    ----------
-    batch_size : int, default=None
-        The number of samples to use for each batch. Only used when calling
-        ``fit``. If ``batch_size`` is ``None``, then ``batch_size``
-        is inferred from the data and set to ``5 * n_features``, to provide a
-        balance between approximation accuracy and memory consumption.
-
-    Attributes
-    ----------
-    location_ : ndarray of shape (n_features,)
-        Estimated location, i.e. the estimated mean.
-
-    covariance_ : ndarray of shape (n_features, n_features)
-        Estimated covariance matrix
-    """
-
-    _onedal_incremental_covariance = staticmethod(onedal_IncrementalEmpiricalCovariance)
-
-    def __init__(self, batch_size=None):
-        self._need_to_finalize = False  # If True then finalize compute should
-        #      be called to obtain covariance_ or location_ from partial compute data
-        self.batch_size = batch_size
-
-    def _onedal_finalize_fit(self):
-        assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit()
-        self._need_to_finalize = False
-
-    def _onedal_partial_fit(self, X, queue):
-        onedal_params = {
-            "method": "dense",
-            "bias": True,
-        }
-        if not hasattr(self, "_onedal_estimator"):
-            self._onedal_estimator = self._onedal_incremental_covariance(**onedal_params)
-        self._onedal_estimator.partial_fit(X, queue)
-        self._need_to_finalize = True
-
-    @property
-    def covariance_(self):
-        if self._need_to_finalize:
-            self._onedal_finalize_fit()
-        return self._onedal_estimator.covariance_
-
-    @property
-    def location_(self):
-        if self._need_to_finalize:
-            self._onedal_finalize_fit()
-        return self._onedal_estimator.location_
-
-    @support_usm_ndarray()
-    def partial_fit(self, X, queue=None):
-        """
-        Incremental fit with X. All of X is processed as a single batch.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-            Training data, where `n_samples` is the number of samples and
-            `n_features` is the number of features.
-
-        Returns
-        -------
-        self : object
-            Returns the instance itself.
-        """
-        X = check_array(X, dtype=[np.float64, np.float32])
-        self._onedal_partial_fit(X, queue)
-        return self
-
-    def fit(self, X, queue=None):
-        """
-        Fit the model with X, using minibatches of size batch_size.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-            Training data, where `n_samples` is the number of samples and
-            `n_features` is the number of features.
-
-        Returns
-        -------
-        self : object
-            Returns the instance itself.
-        """
-        n_samples, n_features = X.shape
-        if self.batch_size is None:
-            batch_size_ = 5 * n_features
-        else:
-            batch_size_ = self.batch_size
-        for batch in gen_batches(n_samples, batch_size_):
-            X_batch = X[batch]
-            self.partial_fit(X_batch, queue=queue)
-
-        self._onedal_finalize_fit()
-        return self

scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/covariance/tests/test_incremental_covariance.py

@@ -1,143 +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.
-# ===============================================================================
-
-import numpy as np
-import pytest
-from numpy.testing import assert_allclose
-
-from onedal.tests.utils._dataframes_support import (
-    _convert_to_dataframe,
-    get_dataframes_and_queues,
-)
-
-
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_sklearnex_partial_fit_on_gold_data(dataframe, queue, dtype):
-    from sklearnex.covariance import IncrementalEmpiricalCovariance
-
-    X = np.array([[0, 1], [0, 1]])
-    X = X.astype(dtype)
-    X_split = np.array_split(X, 2)
-    inccov = IncrementalEmpiricalCovariance()
-
-    for i in range(2):
-        X_split_df = _convert_to_dataframe(
-            X_split[i], sycl_queue=queue, target_df=dataframe
-        )
-        result = inccov.partial_fit(X_split_df)
-
-    expected_covariance = np.array([[0, 0], [0, 0]])
-    expected_means = np.array([0, 1])
-
-    assert_allclose(expected_covariance, result.covariance_)
-    assert_allclose(expected_means, result.location_)
-
-    X = np.array([[1, 2], [3, 6]])
-    X = X.astype(dtype)
-    X_split = np.array_split(X, 2)
-    inccov = IncrementalEmpiricalCovariance()
-
-    for i in range(2):
-        X_split_df = _convert_to_dataframe(
-            X_split[i], sycl_queue=queue, target_df=dataframe
-        )
-        result = inccov.partial_fit(X_split_df)
-
-    expected_covariance = np.array([[1, 2], [2, 4]])
-    expected_means = np.array([2, 4])
-
-    assert_allclose(expected_covariance, result.covariance_)
-    assert_allclose(expected_means, result.location_)
-
-
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("batch_size", [2, 4])
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_sklearnex_fit_on_gold_data(dataframe, queue, batch_size, dtype):
-    from sklearnex.covariance import IncrementalEmpiricalCovariance
-
-    X = np.array([[0, 1, 2, 3], [0, -1, -2, -3], [0, 1, 2, 3], [0, 1, 2, 3]])
-    X = X.astype(dtype)
-    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    inccov = IncrementalEmpiricalCovariance(batch_size=batch_size)
-
-    result = inccov.fit(X_df)
-
-    expected_covariance = np.array(
-        [[0, 0, 0, 0], [0, 0.75, 1.5, 2.25], [0, 1.5, 3, 4.5], [0, 2.25, 4.5, 6.75]]
-    )
-    expected_means = np.array([0, 0.5, 1, 1.5])
-
-    assert_allclose(expected_covariance, result.covariance_)
-    assert_allclose(expected_means, result.location_)
-
-
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("num_batches", [2, 4, 6, 8, 10])
-@pytest.mark.parametrize("row_count", [100, 1000, 2000])
-@pytest.mark.parametrize("column_count", [10, 100, 200])
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_sklearnex_partial_fit_on_random_data(
-    dataframe, queue, num_batches, row_count, column_count, dtype
-):
-    from sklearnex.covariance import IncrementalEmpiricalCovariance
-
-    seed = 77
-    gen = np.random.default_rng(seed)
-    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
-    X = X.astype(dtype)
-    X_split = np.array_split(X, num_batches)
-    inccov = IncrementalEmpiricalCovariance()
-
-    for i in range(num_batches):
-        X_split_df = _convert_to_dataframe(
-            X_split[i], sycl_queue=queue, target_df=dataframe
-        )
-        result = inccov.partial_fit(X_split_df)
-
-    expected_covariance = np.cov(X.T, bias=1)
-    expected_means = np.mean(X, axis=0)
-
-    assert_allclose(expected_covariance, result.covariance_, atol=1e-6)
-    assert_allclose(expected_means, result.location_, atol=1e-6)
-
-
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("num_batches", [2, 4, 6, 8, 10])
-@pytest.mark.parametrize("row_count", [100, 1000, 2000])
-@pytest.mark.parametrize("column_count", [10, 100, 200])
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_sklearnex_fit_on_random_data(
-    dataframe, queue, num_batches, row_count, column_count, dtype
-):
-    from sklearnex.covariance import IncrementalEmpiricalCovariance
-
-    seed = 77
-    gen = np.random.default_rng(seed)
-    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
-    X = X.astype(dtype)
-    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    batch_size = row_count // num_batches
-    inccov = IncrementalEmpiricalCovariance(batch_size=batch_size)
-
-    result = inccov.fit(X_df)
-
-    expected_covariance = np.cov(X.T, bias=1)
-    expected_means = np.mean(X, axis=0)
-
-    assert_allclose(expected_covariance, result.covariance_, atol=1e-6)
-    assert_allclose(expected_means, result.location_, atol=1e-6)