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

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

@@ -0,0 +1,399 @@
+# ==============================================================================
+# 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
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+
+    import numbers
+    import warnings
+
+    import numpy as np
+    from scipy.sparse import issparse
+    from sklearn.cluster import KMeans as _sklearn_KMeans
+    from sklearn.utils._openmp_helpers import _openmp_effective_n_threads
+    from sklearn.utils.validation import (
+        _check_sample_weight,
+        _num_samples,
+        check_is_fitted,
+    )
+
+    from daal4py.sklearn._n_jobs_support import control_n_jobs
+    from daal4py.sklearn._utils import sklearn_check_version
+    from onedal._device_offload import support_input_format
+    from onedal.cluster import KMeans as onedal_KMeans
+    from onedal.utils.validation import _is_csr
+
+    from .._device_offload import dispatch, wrap_output_data
+    from .._utils import PatchingConditionsChain
+    from ..base import oneDALEstimator
+    from ..utils._array_api import get_namespace
+    from ..utils.validation import validate_data
+
+    @control_n_jobs(decorated_methods=["fit", "fit_transform", "predict", "score"])
+    class KMeans(oneDALEstimator, _sklearn_KMeans):
+        __doc__ = _sklearn_KMeans.__doc__
+
+        if sklearn_check_version("1.2"):
+            _parameter_constraints: dict = {**_sklearn_KMeans._parameter_constraints}
+
+        def __init__(
+            self,
+            n_clusters=8,
+            *,
+            init="k-means++",
+            n_init=(
+                "auto"
+                if sklearn_check_version("1.4")
+                else "warn" if sklearn_check_version("1.2") else 10
+            ),
+            max_iter=300,
+            tol=1e-4,
+            verbose=0,
+            random_state=None,
+            copy_x=True,
+            algorithm="lloyd" if sklearn_check_version("1.1") else "auto",
+        ):
+            super().__init__(
+                n_clusters=n_clusters,
+                init=init,
+                max_iter=max_iter,
+                tol=tol,
+                n_init=n_init,
+                verbose=verbose,
+                random_state=random_state,
+                copy_x=copy_x,
+                algorithm=algorithm,
+            )
+
+        def _initialize_onedal_estimator(self):
+            onedal_params = {
+                "n_clusters": self.n_clusters,
+                "init": self.init,
+                "max_iter": self.max_iter,
+                "tol": self.tol,
+                "n_init": self.n_init,
+                "verbose": self.verbose,
+                "random_state": self.random_state,
+            }
+
+            self._onedal_estimator = onedal_KMeans(**onedal_params)
+
+        def _onedal_fit_supported(self, method_name, X, y=None, sample_weight=None):
+            assert method_name == "fit"
+
+            class_name = self.__class__.__name__
+            patching_status = PatchingConditionsChain(f"sklearn.cluster.{class_name}.fit")
+
+            sample_count = _num_samples(X)
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+            correct_count = self.n_clusters < sample_count
+
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+
+            _acceptable_sample_weights = self._validate_sample_weight(sample_weight, X)
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd",
+                    ),
+                    (self.n_clusters != 1, "n_clusters=1 is not supported"),
+                    (correct_count, "n_clusters is smaller than number of samples"),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Accepted options are None, constant, or equal weights.",
+                    ),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        def fit(self, X, y=None, sample_weight=None):
+            if sklearn_check_version("1.2"):
+                self._validate_params()
+
+            dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": _sklearn_KMeans.fit,
+                },
+                X,
+                y,
+                sample_weight,
+            )
+
+            return self
+
+        def _onedal_fit(self, X, _, sample_weight, queue=None):
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                dtype=[np.float64, np.float32],
+                order="C",
+                copy=self.copy_x,
+                accept_large_sparse=False,
+            )
+
+            if sklearn_check_version("1.2"):
+                self._check_params_vs_input(X)
+            else:
+                self._check_params(X)
+
+            self._n_features_out = self.n_clusters
+
+            self._initialize_onedal_estimator()
+            self._n_threads = _openmp_effective_n_threads()
+            self._onedal_estimator.fit(X, queue=queue)
+
+            self._save_attributes()
+
+        def _validate_sample_weight(self, sample_weight, X):
+            if sample_weight is None:
+                return True
+            elif isinstance(sample_weight, numbers.Number) or isinstance(
+                sample_weight, str
+            ):
+                return True
+            else:
+                sample_weight = _check_sample_weight(
+                    sample_weight,
+                    X,
+                    dtype=X.dtype if hasattr(X, "dtype") else None,
+                )
+                if np.all(sample_weight == sample_weight[0]):
+                    return True
+                else:
+                    return False
+
+        def _onedal_predict_supported(self, method_name, *data):
+            class_name = self.__class__.__name__
+
+            patching_status = PatchingConditionsChain(
+                f"sklearn.cluster.{class_name}.{method_name}"
+            )
+
+            X = data[0]
+            sample_weight = data[-1] if len(data) > 1 else None
+
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+
+            # algorithm "auto" has been deprecated since 1.1,
+            # algorithm "full" has been replaced by "lloyd"
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+
+            _acceptable_sample_weights = True
+            if not sklearn_check_version("1.5"):
+                _acceptable_sample_weights = self._validate_sample_weight(
+                    sample_weight, X
+                )
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd.",
+                    ),
+                    (self.n_clusters != 1, "n_clusters=1 is not supported"),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Acceptable options are None, constant, or equal weights.",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        if sklearn_check_version("1.5"):
+
+            @wrap_output_data
+            def predict(self, X):
+                self._validate_params()
+                check_is_fitted(self)
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": _sklearn_KMeans.predict,
+                    },
+                    X,
+                )
+
+        else:
+
+            @wrap_output_data
+            def predict(
+                self,
+                X,
+                sample_weight="deprecated" if sklearn_check_version("1.3") else None,
+            ):
+                if sklearn_check_version("1.2"):
+                    self._validate_params()
+
+                if sklearn_check_version("1.3"):
+                    if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                        sample_weight = None
+
+                    if sample_weight is not None:
+                        warnings.warn(
+                            "'sample_weight' was deprecated in version 1.3 and "
+                            "will be removed in 1.5.",
+                            FutureWarning,
+                        )
+                check_is_fitted(self)
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": _sklearn_KMeans.predict,
+                    },
+                    X,
+                    sample_weight,
+                )
+
+        def _onedal_predict(self, X, sample_weight=None, queue=None):
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.predict(X, queue=queue)
+
+        def _onedal_supported(self, method_name, *data):
+            if method_name == "fit":
+                return self._onedal_fit_supported(method_name, *data)
+            if method_name in ["predict", "score"]:
+                return self._onedal_predict_supported(method_name, *data)
+            raise RuntimeError(
+                f"Unknown method {method_name} in {self.__class__.__name__}"
+            )
+
+        _onedal_gpu_supported = _onedal_supported
+        _onedal_cpu_supported = _onedal_supported
+
+        def _check_test_data(self, X):
+            xp, _ = get_namespace(X)
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[xp.float64, xp.float32],
+                order="C",
+                accept_large_sparse=False,
+            )
+            return X
+
+        _transform = support_input_format(_sklearn_KMeans._transform)
+        transform = support_input_format(_sklearn_KMeans.transform)
+
+        @wrap_output_data
+        def score(self, X, y=None, sample_weight=None):
+            check_is_fitted(self)
+            return dispatch(
+                self,
+                "score",
+                {
+                    "onedal": self.__class__._onedal_score,
+                    "sklearn": _sklearn_KMeans.score,
+                },
+                X,
+                y,
+                sample_weight,
+            )
+
+        def _onedal_score(self, X, y=None, sample_weight=None, queue=None):
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not sklearn_check_version("1.5") and sklearn_check_version("1.3"):
+                if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                    sample_weight = None
+
+                if sample_weight is not None:
+                    warnings.warn(
+                        "'sample_weight' was deprecated in version 1.3 and "
+                        "will be removed in 1.5.",
+                        FutureWarning,
+                    )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.score(X, queue=queue)
+
+        def _save_attributes(self):
+            assert hasattr(self, "_onedal_estimator")
+            self.cluster_centers_ = self._onedal_estimator.cluster_centers_
+            self.labels_ = self._onedal_estimator.labels_
+            self.inertia_ = self._onedal_estimator.inertia_
+            self.n_iter_ = self._onedal_estimator.n_iter_
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+
+            self._n_init = self._onedal_estimator._n_init
+
+        fit.__doc__ = _sklearn_KMeans.fit.__doc__
+        predict.__doc__ = _sklearn_KMeans.predict.__doc__
+        score.__doc__ = _sklearn_KMeans.score.__doc__
+
+else:
+    from daal4py.sklearn.cluster import KMeans
+
+    logging.warning(
+        "Sklearnex KMeans requires oneDAL version >= 2023.2, falling back to daal4py."
+    )

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/cluster/tests/test_dbscan.py

@@ -0,0 +1,38 @@
+# ===============================================================================
+# 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 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())
+def test_sklearnex_import_dbscan(dataframe, queue):
+    from sklearnex.cluster import DBSCAN
+
+    X = np.array([[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]])
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    dbscan = DBSCAN(eps=3, min_samples=2).fit(X)
+    assert "sklearnex" in dbscan.__module__
+
+    result = dbscan.labels_
+    expected = np.array([0, 0, 0, 1, 1, -1], dtype=np.int32)
+    assert_allclose(expected, result)

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

@@ -0,0 +1,157 @@
+# ===============================================================================
+# 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 numpy.testing import assert_allclose
+from scipy.sparse import csr_matrix
+from sklearn.datasets import make_blobs
+
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+    get_queues,
+)
+from sklearnex import config_context
+from sklearnex.tests.utils import _IS_INTEL
+
+
+def generate_dense_dataset(n_samples, n_features, density, n_clusters):
+    np.random.seed(2024 + n_samples + n_features + n_clusters)
+    X, _ = make_blobs(
+        n_samples=n_samples,
+        n_features=n_features,
+        centers=n_clusters,
+        cluster_std=1.0,
+        random_state=42,
+    )
+    mask = np.random.binomial(1, density, (n_samples, n_features))
+    X = X * mask
+    return X
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_dense_data(dataframe, queue, algorithm, init):
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_dense_df = _convert_to_dataframe(X_dense, sycl_queue=queue, target_df=dataframe)
+
+    kmeans_dense = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_dense_df)
+
+    if daal_check_version((2023, "P", 200)):
+        assert "sklearnex" in kmeans_dense.__module__
+    else:
+        assert "daal4py" in kmeans_dense.__module__
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_sparse_data(queue, algorithm, init):
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_sparse = csr_matrix(X_dense)
+
+    kmeans_sparse = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_sparse)
+
+    assert "sklearnex" in kmeans_sparse.__module__
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+def test_results_on_dense_gold_data(dataframe, queue, algorithm):
+    from sklearnex.cluster import KMeans
+
+    X_train = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
+    X_test = np.array([[0, 0], [12, 3]])
+    X_train_df = _convert_to_dataframe(X_train, sycl_queue=queue, target_df=dataframe)
+    X_test_df = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+
+    kmeans = KMeans(n_clusters=2, random_state=0, algorithm=algorithm).fit(X_train_df)
+
+    if queue and queue.sycl_device.is_gpu:
+        # KMeans Init Dense GPU implementation is different from CPU
+        expected_cluster_labels = np.array([0, 1], dtype=np.int32)
+        expected_cluster_centers = np.array([[1.0, 2.0], [10.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+    else:
+        expected_cluster_labels = np.array([1, 0], dtype=np.int32)
+        expected_cluster_centers = np.array([[10.0, 2.0], [1.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+
+    assert_allclose(expected_cluster_labels, _as_numpy(kmeans.predict(X_test_df)))
+    assert_allclose(expected_cluster_centers, _as_numpy(kmeans.cluster_centers_))
+    assert expected_inertia == kmeans.inertia_
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("init", ["k-means++", "random", "arraylike"])
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+@pytest.mark.parametrize(
+    "dims", [(1000, 10, 0.95, 3), (50000, 100, 0.75, 10), (10000, 10, 0.8, 5)]
+)
+def test_dense_vs_sparse(queue, init, algorithm, dims):
+    from sklearnex.cluster import KMeans
+
+    if init == "random" or (not _IS_INTEL and init == "k-means++"):
+        pytest.skip(f"{init} initialization for sparse K-means is non-conformant.")
+
+    # For higher level of sparsity (smaller density) the test may fail
+    n_samples, n_features, density, n_clusters = dims
+    X_dense = generate_dense_dataset(n_samples, n_features, density, n_clusters)
+    X_sparse = csr_matrix(X_dense)
+
+    if init == "arraylike":
+        np.random.seed(2024 + n_samples + n_features + n_clusters)
+        init = X_dense[np.random.choice(n_samples, size=n_clusters, replace=False)]
+
+    kmeans_dense = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_dense)
+    kmeans_sparse = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_sparse)
+
+    assert_allclose(
+        kmeans_dense.cluster_centers_,
+        kmeans_sparse.cluster_centers_,
+    )

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/conftest.py

@@ -0,0 +1,82 @@
+# ==============================================================================
+# 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 io
+import logging
+
+import pytest
+
+from daal4py.sklearn._utils import sklearn_check_version
+from sklearnex import config_context, patch_sklearn, unpatch_sklearn
+
+
+def pytest_configure(config):
+    config.addinivalue_line(
+        "markers", "allow_sklearn_fallback: mark test to not check for sklearnex usage"
+    )
+    config.addinivalue_line(
+        "markers", "mpi: mark test to require MPI for distributed testing"
+    )
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_call(item):
+    # setup logger to check for sklearn fallback
+    if not item.get_closest_marker("allow_sklearn_fallback"):
+        log_stream = io.StringIO()
+        log_handler = logging.StreamHandler(log_stream)
+        sklearnex_logger = logging.getLogger("sklearnex")
+        level = sklearnex_logger.level
+        sklearnex_stderr_handler = sklearnex_logger.handlers
+        sklearnex_logger.handlers = []
+        sklearnex_logger.addHandler(log_handler)
+        sklearnex_logger.setLevel(logging.INFO)
+        log_handler.setLevel(logging.INFO)
+
+        yield
+
+        sklearnex_logger.handlers = sklearnex_stderr_handler
+        sklearnex_logger.setLevel(level)
+        sklearnex_logger.removeHandler(log_handler)
+        text = log_stream.getvalue()
+        if "fallback to original Scikit-learn" in text:
+            raise TypeError(
+                f"test did not properly evaluate sklearnex functionality and fell back to sklearn:\n{text}"
+            )
+    else:
+        yield
+
+
+@pytest.fixture
+def with_sklearnex():
+    patch_sklearn()
+    yield
+    unpatch_sklearn()
+
+
+@pytest.fixture
+def with_array_api():
+    if sklearn_check_version("1.2"):
+        with config_context(array_api_dispatch=True):
+            yield
+    else:
+        yield
+
+
+@pytest.fixture
+def without_allow_sklearn_after_onedal():
+    with config_context(allow_sklearn_after_onedal=False):
+        yield

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/covariance/__init__.py

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