scikit-learn-intelex 2023.2.1__py311-none-win_amd64.whl → 2024.0.1__py311-none-win_amd64.whl

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/preview/decomposition/pca.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,34 +13,37 @@
 # 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 numbers
 from math import sqrt
+
+import numpy as np
 from scipy.sparse import issparse
+from sklearn.base import BaseEstimator
+from sklearn.utils.extmath import stable_cumsum
+from sklearn.utils.validation import check_array, check_is_fitted
 
-from ..._device_offload import dispatch
 from daal4py.sklearn._utils import sklearn_check_version
+from onedal.utils import _check_array
 
-from sklearn.utils.extmath import stable_cumsum
-from onedal.datatypes import _check_array
-from sklearn.utils.validation import check_array
-from sklearn.base import BaseEstimator
-from sklearn.utils.validation import check_is_fitted
-if sklearn_check_version('1.1') and not sklearn_check_version('1.2'):
+from ..._device_offload import dispatch
+from ..._utils import PatchingConditionsChain
+
+if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
     from sklearn.utils import check_scalar
-if sklearn_check_version('0.23'):
+if sklearn_check_version("0.23"):
     from sklearn.decomposition._pca import _infer_dimension
 else:
     from sklearn.decomposition._pca import _infer_dimension_
 
-from onedal.decomposition import PCA as onedal_PCA
 from sklearn.decomposition import PCA as sklearn_PCA
 
+from onedal.decomposition import PCA as onedal_PCA
+
 
 class PCA(sklearn_PCA):
-    if sklearn_check_version('1.2'):
+    if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**sklearn_PCA._parameter_constraints}
 
     def __init__(
@@ -66,13 +69,11 @@ class PCA(sklearn_PCA):
         self.power_iteration_normalizer = power_iteration_normalizer
         self.random_state = random_state
 
-    def _validate_n_components(self, n_components, n_samples,
-                               n_features, n_sf_min):
+    def _validate_n_components(self, n_components, n_samples, n_features, n_sf_min):
         if n_components == "mle":
             if n_samples < n_features:
                 raise ValueError(
-                    "n_components='mle' is only supported if"
-                    " n_samples >= n_features"
+                    "n_components='mle' is only supported if" " n_samples >= n_features"
                 )
         elif not 0 <= n_components <= n_sf_min:
             raise ValueError(
@@ -82,15 +83,16 @@ class PCA(sklearn_PCA):
             )
         elif n_components >= 1:
             if not isinstance(n_components, numbers.Integral):
-                raise ValueError("n_components=%r must be of type int "
-                                 "when greater than or equal to 1, "
-                                 "was of type=%r"
-                                 % (n_components, type(n_components)))
+                raise ValueError(
+                    "n_components=%r must be of type int "
+                    "when greater than or equal to 1, "
+                    "was of type=%r" % (n_components, type(n_components))
+                )
 
     def fit(self, X, y=None):
-        if sklearn_check_version('1.2'):
+        if sklearn_check_version("1.2"):
             self._validate_params()
-        elif sklearn_check_version('1.1'):
+        elif sklearn_check_version("1.1"):
             check_scalar(
                 self.n_oversamples,
                 "n_oversamples",
@@ -107,12 +109,14 @@ class PCA(sklearn_PCA):
                 "TruncatedSVD for a possible alternative."
             )
 
-        if sklearn_check_version('0.23'):
-            X = self._validate_data(X, dtype=[np.float64, np.float32],
-                                    ensure_2d=True, copy=False)
+        if sklearn_check_version("0.23"):
+            X = self._validate_data(
+                X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
+            )
         else:
-            X = _check_array(X, dtype=[np.float64, np.float32],
-                             ensure_2d=True, copy=False)
+            X = _check_array(
+                X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
+            )
 
         n_samples, n_features = X.shape
         n_sf_min = min(n_samples, n_features)
@@ -125,13 +129,12 @@ class PCA(sklearn_PCA):
         else:
             n_components = self.n_components
 
-        self._validate_n_components(n_components, n_samples, n_features,
-                                    n_sf_min)
+        self._validate_n_components(n_components, n_samples, n_features, n_sf_min)
 
         self._fit_svd_solver = self.svd_solver
         shape_good_for_daal = X.shape[1] / X.shape[0] < 2
         if self._fit_svd_solver == "auto":
-            if sklearn_check_version('1.1'):
+            if sklearn_check_version("1.1"):
                 if max(X.shape) <= 500 or n_components == "mle":
                     self._fit_svd_solver = "full"
                 elif 1 <= n_components < 0.8 * n_sf_min:
@@ -139,69 +142,93 @@ class PCA(sklearn_PCA):
                 else:
                     self._fit_svd_solver = "full"
             else:
-                if n_components == 'mle':
-                    self._fit_svd_solver = 'full'
+                if n_components == "mle":
+                    self._fit_svd_solver = "full"
                 else:
                     n, p, k = X.shape[0], X.shape[1], n_components
                     # check if sklearnex is faster than randomized sklearn
                     # Refer to daal4py
-                    regression_coefs = np.array([
-                        [9.779873e-11, n * p * k],
-                        [-1.122062e-11, n * p * p],
-                        [1.127905e-09, n ** 2],
-                    ])
-
-                    if n_components >= 1 and np.dot(
-                            regression_coefs[:, 0],
-                            regression_coefs[:, 1]) <= 0:
-                        self._fit_svd_solver = 'randomized'
+                    regression_coefs = np.array(
+                        [
+                            [9.779873e-11, n * p * k],
+                            [-1.122062e-11, n * p * p],
+                            [1.127905e-09, n**2],
+                        ]
+                    )
+
+                    if (
+                        n_components >= 1
+                        and np.dot(regression_coefs[:, 0], regression_coefs[:, 1]) <= 0
+                    ):
+                        self._fit_svd_solver = "randomized"
                     else:
-                        self._fit_svd_solver = 'full'
+                        self._fit_svd_solver = "full"
 
-        if not shape_good_for_daal or self._fit_svd_solver != 'full':
-            if sklearn_check_version('0.23'):
+        if not shape_good_for_daal or self._fit_svd_solver != "full":
+            if sklearn_check_version("0.23"):
                 X = self._validate_data(X, copy=self.copy)
             else:
                 X = check_array(X, copy=self.copy)
 
         # Call different fits for either full or truncated SVD
         if shape_good_for_daal and self._fit_svd_solver == "full":
-            return dispatch(self, 'fit', {
-                'onedal': self.__class__._onedal_fit,
-                'sklearn': sklearn_PCA._fit_full,
-            }, X)
+            return dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": sklearn_PCA._fit_full,
+                },
+                X,
+            )
         elif not shape_good_for_daal and self._fit_svd_solver == "full":
             return sklearn_PCA._fit_full(self, X, n_components)
         elif self._fit_svd_solver in ["arpack", "randomized"]:
             return sklearn_PCA._fit_truncated(
-                self, X, n_components, self._fit_svd_solver,
+                self,
+                X,
+                n_components,
+                self._fit_svd_solver,
             )
         else:
-            raise ValueError(
-                "Unrecognized svd_solver='{0}'".format(self._fit_svd_solver)
-            )
+            raise ValueError("Unrecognized svd_solver='{0}'".format(self._fit_svd_solver))
 
-    def _onedal_gpu_supported(self, method_name, *data):
-        if method_name == 'fit':
-            return self._fit_svd_solver == 'full'
-        elif method_name == 'transform':
-            return hasattr(self, '_onedal_estimator')
-        raise RuntimeError(
-            f'Unknown method {method_name} in {self.__class__.__name__}'
-        )
+    def _onedal_supported(self, method_name, *data):
+        class_name = self.__class__.__name__
+        if method_name == "fit":
+            patching_status = PatchingConditionsChain(
+                f"sklearn.decomposition.{class_name}.{method_name}"
+            )
+            patching_status.and_conditions(
+                [
+                    (
+                        self._fit_svd_solver == "full",
+                        f"'{self._fit_svd_solver}' SVD solver is not supported. "
+                        "Only 'full' solver is supported.",
+                    ),
+                ]
+            )
+            return patching_status
+        elif method_name == "transform":
+            patching_status = PatchingConditionsChain(
+                f"sklearn.decomposition.{class_name}.{method_name}"
+            )
+            patching_status.and_conditions(
+                [
+                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained"),
+                ]
+            )
+            return patching_status
+        raise RuntimeError(f"Unknown method {method_name} in {self.__class__.__name__}")
 
     def _onedal_cpu_supported(self, method_name, *data):
-        if method_name == 'fit':
-            return self._fit_svd_solver == 'full'
-        elif method_name == 'transform':
-            return hasattr(self, '_onedal_estimator')
-        raise RuntimeError(
-            f'Unknown method {method_name} in {self.__class__.__name__}'
-        )
+        return self._onedal_supported(method_name, *data)
 
-    def _onedal_fit(self, X, y=None, queue=None):
+    def _onedal_gpu_supported(self, method_name, *data):
+        return self._onedal_supported(method_name, *data)
 
-        if self.n_components == 'mle' or self.n_components is None:
+    def _onedal_fit(self, X, y=None, queue=None):
+        if self.n_components == "mle" or self.n_components is None:
             onedal_n_components = min(X.shape)
         elif 0 < self.n_components < 1:
             onedal_n_components = min(X.shape)
@@ -209,9 +236,9 @@ class PCA(sklearn_PCA):
             onedal_n_components = self.n_components
 
         onedal_params = {
-            'n_components': onedal_n_components,
-            'is_deterministic': True,
-            'method': "precomputed",
+            "n_components": onedal_n_components,
+            "is_deterministic": True,
+            "method": "precomputed",
         }
         self._onedal_estimator = onedal_PCA(**onedal_params)
         self._onedal_estimator.fit(X, queue=queue)
@@ -227,12 +254,7 @@ class PCA(sklearn_PCA):
         return self._onedal_estimator.predict(X, queue)
 
     def _onedal_transform(self, X):
-        X = _check_array(
-            X,
-            dtype=[np.float64, np.float32],
-            ensure_2d=True,
-            copy=False
-        )
+        X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False)
 
         if hasattr(self, "n_features_in_"):
             if self.n_features_in_ != X.shape[1]:
@@ -251,10 +273,15 @@ class PCA(sklearn_PCA):
 
         # Mean center
         X_centered = X - self.mean_
-        return dispatch(self, 'transform', {
-            'onedal': self.__class__._onedal_predict,
-            'sklearn': sklearn_PCA.transform,
-        }, X_centered)
+        return dispatch(
+            self,
+            "transform",
+            {
+                "onedal": self.__class__._onedal_predict,
+                "sklearn": sklearn_PCA.transform,
+            },
+            X_centered,
+        )
 
     def transform(self, X):
         check_is_fitted(self)
@@ -310,13 +337,12 @@ class PCA(sklearn_PCA):
         self.mean_ = self._onedal_estimator.mean_
         self.singular_values_ = self._onedal_estimator.singular_values_
         self.explained_variance_ = self._onedal_estimator.explained_variance_
-        self.explained_variance_ratio_ = \
-            self._onedal_estimator.explained_variance_ratio_
+        self.explained_variance_ratio_ = self._onedal_estimator.explained_variance_ratio_
 
         if self.n_components is None:
             self.n_components_ = self._onedal_estimator.n_components_
-        elif self.n_components == 'mle':
-            if sklearn_check_version('0.23'):
+        elif self.n_components == "mle":
+            if sklearn_check_version("0.23"):
                 self.n_components_ = _infer_dimension(
                     self.explained_variance_, self.n_samples_
                 )
@@ -326,23 +352,25 @@ class PCA(sklearn_PCA):
                 )
         elif 0 < self.n_components < 1.0:
             ratio_cumsum = stable_cumsum(self.explained_variance_ratio_)
-            self.n_components_ = np.searchsorted(
-                ratio_cumsum, self.n_components, side='right') + 1
+            self.n_components_ = (
+                np.searchsorted(ratio_cumsum, self.n_components, side="right") + 1
+            )
         else:
             self.n_components_ = self._onedal_estimator.n_components_
 
         if self.n_components_ < n_sf_min:
             if self.explained_variance_.shape[0] == n_sf_min:
-                self.noise_variance_ = \
-                    self.explained_variance_[self.n_components_:].mean()
+                self.noise_variance_ = self.explained_variance_[
+                    self.n_components_ :
+                ].mean()
             else:
                 self.noise_variance_ = self._onedal_estimator.noise_variance_
         else:
-            self.noise_variance_ = 0.
-
-        self.explained_variance_ = self.explained_variance_[:self.n_components_]
-        self.explained_variance_ratio_ = \
-            self.explained_variance_ratio_[:self.n_components_]
-        self.components_ = \
-            self._onedal_estimator.components_[:self.n_components_]
-        self.singular_values_ = self.singular_values_[:self.n_components_]
+            self.noise_variance_ = 0.0
+
+        self.explained_variance_ = self.explained_variance_[: self.n_components_]
+        self.explained_variance_ratio_ = self.explained_variance_ratio_[
+            : self.n_components_
+        ]
+        self.components_ = self._onedal_estimator.components_[: self.n_components_]
+        self.singular_values_ = self.singular_values_[: self.n_components_]

scikit_learn_intelex-2023.2.1.data/data/Lib/site-packages/sklearnex/preview/linear_model/tests/test_preview_linear.py → scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/preview/decomposition/tests/test_preview_pca.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 # ===============================================================================
-# Copyright 2021 Intel Corporation
+# 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.
@@ -16,21 +16,23 @@
 # ===============================================================================
 
 import numpy as np
+import pytest
 from numpy.testing import assert_allclose
-from sklearn.datasets import make_regression
-from daal4py.sklearn._utils import daal_check_version
 
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
 
-def test_sklearnex_import_linear():
-    from sklearnex.preview.linear_model import LinearRegression
-    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
-    y = np.dot(X, np.array([1, 2])) + 3
-    linreg = LinearRegression().fit(X, y)
-    if daal_check_version((2023, 'P', 100)):
-        assert 'sklearnex' in linreg.__module__
-        assert hasattr(linreg, '_onedal_estimator')
-    else:
-        assert 'daal4py' in linreg.__module__
-    assert linreg.n_features_in_ == 2
-    assert_allclose(linreg.intercept_, 3.)
-    assert_allclose(linreg.coef_, [1., 2.])
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import(dataframe, queue):
+    from sklearnex.preview.decomposition import PCA
+
+    X = [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    pca = PCA(n_components=2, svd_solver="full").fit(X)
+    assert "sklearnex" in pca.__module__
+    assert hasattr(pca, "_onedal_estimator")
+    assert_allclose(_as_numpy(pca.singular_values_), [6.30061232, 0.54980396])

{scikit_learn_intelex-2023.2.1.data/data/Lib/site-packages/sklearnex/preview/linear_model → scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/spmd}/__init__.py

@@ -1,22 +1,24 @@
-#!/usr/bin/env python
-#===============================================================================
-# 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 .linear import LinearRegression
-
-__all__ = [
-    'LinearRegression'
-]
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+__all__ = [
+    "basic_statistics",
+    "cluster",
+    "decomposition",
+    "ensemble",
+    "linear_model",
+    "neighbors",
+]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/basic_statistics/__init__.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,8 +12,8 @@
 # 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 .basic_statistics import BasicStatistics
 
-__all__ = ['BasicStatistics']
+__all__ = ["BasicStatistics"]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/basic_statistics/basic_statistics.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,7 +12,7 @@
 # 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.spmd.basic_statistics import BasicStatistics
 

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/cluster/__init__.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,13 +12,19 @@
 # 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._utils import daal_check_version
 
-if daal_check_version((2023, 'P', 200)):
+from .dbscan import DBSCAN
+
+if daal_check_version((2023, "P", 200)):
     from .kmeans import KMeans
 
-    __all__ = ['KMeans']
+    __all__ = ["DBSCAN", "KMeans"]
 else:
-    __all__ = []
+    # TODO:
+    # update versioning for DBSCAN.
+    __all__ = [
+        "DBSCAN",
+    ]

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/spmd/cluster/dbscan.py

@@ -0,0 +1,50 @@
+# ==============================================================================
+# 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 abc import ABC
+
+from onedal.spmd.cluster import DBSCAN as onedal_DBSCAN
+
+from ...cluster import DBSCAN as DBSCAN_Batch
+
+
+class BaseDBSCANspmd(ABC):
+    def _onedal_dbscan(self, **onedal_params):
+        return onedal_DBSCAN(**onedal_params)
+
+
+class DBSCAN(BaseDBSCANspmd, DBSCAN_Batch):
+    __doc__ = DBSCAN_Batch.__doc__
+
+    def _onedal_cpu_supported(self, method_name, *data):
+        # TODO:
+        # check which methods supported SPMD interface on CPU.
+        ready = super()._onedal_cpu_supported(method_name, *data)
+        if not ready:
+            raise RuntimeError(
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
+        return ready
+
+    def _onedal_gpu_supported(self, method_name, *data):
+        ready = super()._onedal_gpu_supported(method_name, *data)
+        if not ready:
+            raise RuntimeError(
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
+        return ready

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/cluster/kmeans.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,7 +12,7 @@
 # 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.spmd.cluster import KMeans
 

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/__init__.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,8 +12,8 @@
 # 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 .pca import PCA
 
-__all__ = ['PCA']
+__all__ = ["PCA"]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/pca.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,7 +12,7 @@
 # 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.spmd.decomposition import PCA
 

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/spmd/ensemble/__init__.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,8 +12,8 @@
 # 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 .forest import RandomForestClassifier, RandomForestRegressor
 
-__all__ = ['RandomForestClassifier', 'RandomForestRegressor']
+__all__ = ["RandomForestClassifier", "RandomForestRegressor"]